Il y a quelques nuances dans différents cas d'utilisation, mais généralement un trait de soulignement signifie «ignorer cela».
Lors de la déclaration d'une nouvelle fonction, un trait de soulignement indique à Swift que le paramètre ne doit pas avoir d'étiquette lorsqu'il est appelé - c'est le cas que vous voyez. Une déclaration de fonction plus complète ressemble à ceci:
func myFunc(label name: Int) // call it like myFunc(label: 3)
"label" est une étiquette d'argument et doit être présente lorsque vous appelez la fonction. (Et depuis Swift 3, les étiquettes sont requises pour tous les arguments par défaut.) "Nom" est le nom de la variable pour cet argument que vous utilisez dans la fonction. Un formulaire plus court ressemble à ceci:
func myFunc(name: Int) // call it like myFunc(name: 3)
Il s'agit d'un raccourci qui vous permet d'utiliser le même mot pour l'étiquette d'argument externe et le nom du paramètre interne. C'est équivalent à func myFunc(name name: Int).
Si vous souhaitez que votre fonction puisse être appelée sans étiquettes de paramètres, vous utilisez le trait _de soulignement pour que l'étiquette ne soit rien / ignorée. (Dans ce cas, vous devez fournir un nom interne si vous souhaitez pouvoir utiliser le paramètre.)
func myFunc(_ name: Int) // call it like myFunc(3)
Dans une instruction d'affectation, un trait de soulignement signifie "ne pas affecter à quoi que ce soit". Vous pouvez l'utiliser si vous souhaitez appeler une fonction qui renvoie un résultat mais ne se soucie pas de la valeur renvoyée.
_ = someFunction()
Ou, comme dans l'article auquel vous avez lié, pour ignorer un élément d'un tuple retourné:
let (x, _) = someFunctionThatReturnsXandY()
Lorsque vous écrivez une fermeture qui implémente un type de fonction défini, vous pouvez utiliser le trait de soulignement pour ignorer certains paramètres.
PHPhotoLibrary.performChanges( { /* some changes */ },
completionHandler: { success, _ in // don't care about error
if success { print("yay") }
})
De même, lors de la déclaration d'une fonction qui adopte un protocole ou remplace une méthode de superclasse, vous pouvez utiliser _pour les noms de paramètres pour ignorer les paramètres. Étant donné que le protocole / la superclasse peut également définir que le paramètre n'a pas d'étiquette, vous pouvez même vous retrouver avec deux traits de soulignement à la suite.
class MyView: NSView {
override func mouseDown(with _: NSEvent) {
// don't care about event, do same thing for every mouse down
}
override func draw(_ _: NSRect) {
// don't care about dirty rect, always redraw the whole view
}
}
Un peu lié aux deux derniers styles: lorsque vous utilisez une construction de contrôle de flux qui lie une variable / constante locale, vous pouvez l'utiliser _pour l'ignorer. Par exemple, si vous souhaitez itérer une séquence sans avoir besoin d'accéder à ses membres:
for _ in 1...20 { // or 0..<20
// do something 20 times
}
Si vous liez des cas de tuple dans une instruction switch, le trait de soulignement peut fonctionner comme un caractère générique, comme dans cet exemple (raccourci à partir de celui du langage de programmation Swift ):
switch somePoint { // somePoint is an (Int, Int) tuple
case (0, 0):
print("(0, 0) is at the origin")
case (_, 0):
print("(\(somePoint.0), 0) is on the x-axis")
case (0, _):
print("(0, \(somePoint.1)) is on the y-axis")
default:
print("(\(somePoint.0), \(somePoint.1)) isn't on an axis")
}
Une dernière chose qui est pas tout à fait comparables , mais que je rajouterais depuis (comme indiqué par les commentaires) il semble amener les gens ici: Un trait de soulignement dans un identifiant - par exemple var _foo, func do_the_thing(),struct Stuff_ - des moyens rien en particulier à Swift, mais a quelques utilisations parmi les programmeurs.
Les traits de soulignement dans un nom sont un choix de style, mais pas préféré dans la communauté Swift, qui a de fortes conventions sur l'utilisation d'UpperCamelCase pour les types et de lowerCamelCase pour tous les autres symboles.
Le préfixage ou le suffixe d'un nom de symbole avec un trait de soulignement est une convention de style, historiquement utilisée pour distinguer les symboles privés / à usage interne uniquement de l'API exportée. Cependant, Swift a des modificateurs d'accès pour cela, donc cette convention est généralement considérée comme non idiomatique dans Swift.
Quelques symboles avec des préfixes à double trait de soulignement ( func __foo()) se cachent dans les profondeurs des SDK d'Apple: Ce sont des symboles (Obj) C importés dans Swift à l'aide de l' NS_REFINED_FOR_SWIFTattribut. Apple l'utilise lorsqu'ils veulent créer une version "plus Swifty" d'une API (Obj) C - par exemple, pour transformer une méthode indépendante du type en méthode générique . Ils doivent utiliser l'API importée pour faire fonctionner la version raffinée de Swift, ils utilisent donc le __pour la maintenir disponible tout en la cachant de la plupart des outils et de la documentation.