Hay algunos matices para diferentes casos de uso, pero generalmente un guión bajo significa "ignorar esto".
Al declarar una nueva función, un guión bajo le dice a Swift que el parámetro no debe tener etiqueta cuando se lo llama, ese es el caso que está viendo. Una declaración de función más completa se ve así:
func myFunc(label name: Int) // call it like myFunc(label: 3)
"etiqueta" es una etiqueta de argumento y debe estar presente cuando se llama a la función. (Y desde Swift 3, se requieren etiquetas para todos los argumentos de forma predeterminada). "Nombre" es el nombre de la variable para ese argumento que utiliza dentro de la función. Una forma más corta se ve así:
func myFunc(name: Int) // call it like myFunc(name: 3)
Este es un acceso directo que le permite usar la misma palabra para la etiqueta del argumento externo y el nombre del parámetro interno. Es equivalente a func myFunc(name name: Int).
Si desea que su función sea invocable sin etiquetas de parámetros, use el guión bajo _para que la etiqueta sea nada / ignorada. (En ese caso, debe proporcionar un nombre interno si desea poder utilizar el parámetro).
func myFunc(_ name: Int) // call it like myFunc(3)
En una declaración de asignación, un guión bajo significa "no asignar a nada". Puede usar esto si desea llamar a una función que devuelve un resultado pero no le importa el valor devuelto.
_ = someFunction()
O, como en el artículo al que se vinculó, ignorar un elemento de una tupla devuelta:
let (x, _) = someFunctionThatReturnsXandY()
Cuando escribe un cierre que implementa algún tipo de función definida, puede usar el guión bajo para ignorar ciertos parámetros.
PHPhotoLibrary.performChanges( { /* some changes */ },
completionHandler: { success, _ in // don't care about error
if success { print("yay") }
})
Del mismo modo, al declarar una función que adopta un protocolo o anula un método de superclase, puede usar los nombres de los_ parámetros para ignorarlos. Dado que el protocolo / superclase también podría definir que el parámetro no tiene etiqueta, incluso puede terminar con dos guiones bajos seguidos.
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
}
}
Algo relacionado con los dos últimos estilos: cuando se usa una construcción de control de flujo que une una variable / constante local, puede usar _para ignorarla. Por ejemplo, si desea iterar una secuencia sin necesidad de acceder a sus miembros:
for _ in 1...20 { // or 0..<20
// do something 20 times
}
Si está vinculando casos de tupla en una declaración de cambio, el guión bajo puede funcionar como un comodín, como en este ejemplo (acortado de uno en El lenguaje de programación rápido ):
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")
}
Una última cosa que no está muy relacionado, pero que voy a incluir ya que (según lo observado por los comentarios) que parece conducir a la gente aquí: Un guión en un identificador - por ejemplo var _foo, func do_the_thing(), struct Stuff_- medios nada en particular a Swift, pero tiene algunos usos entre programadores.
Los guiones bajos dentro de un nombre son una opción de estilo, pero no se prefieren en la comunidad Swift, que tiene convenciones fuertes sobre el uso de UpperCamelCase para los tipos y lowerCamelCase para todos los demás símbolos.
Prefijar o sufijar un nombre de símbolo con guión bajo es una convención de estilo, históricamente utilizada para distinguir símbolos privados / de uso interno de la API exportada. Sin embargo, Swift tiene modificadores de acceso para eso, por lo que esta convención generalmente se considera no idiomática en Swift.
Algunos símbolos con prefijos de doble subrayado ( func __foo()) acechan en las profundidades de los SDK de Apple: estos son símbolos (Obj) C importados a Swift usando el NS_REFINED_FOR_SWIFTatributo. Apple usa eso cuando quieren hacer una versión "más ágil" de una API (Obj) C, por ejemplo, para convertir un método independiente del tipo en un método genérico . Necesitan usar la API importada para hacer que la versión refinada de Swift funcione, por lo que la usan __para mantenerla disponible mientras la ocultan de la mayoría de las herramientas y la documentación.