the - swift wikipedia

¿Por qué necesito guiones bajos en Swift?

Question

Here dice: "Nota: el _ significa" No me importa ese valor "", pero viniendo de JavaScript, no entiendo lo que eso significa.

La única forma en que puedo imprimir estas funciones es usando los guiones bajos antes de los parámetros:

func divmod(_ a: Int, _ b:Int) -> (Int, Int) {
    return (a / b, a % b)
}

print(divmod(7, 3))
print(divmod(5, 2))
print(divmod(12,4))

Sin los guiones bajos, tengo que escribirlo así para evitar errores:

func divmod(a: Int, b:Int) -> (Int, Int) {
    return (a / b, a % b)
}

print(divmod(a: 7, b: 3))
print(divmod(a: 5, b: 2))
print(divmod(a: 12,b: 4))

No entiendo este uso de subrayado. ¿Cuándo, cómo y por qué uso estos guiones bajos?

Answer 1

Desde Swift 3, la especificación de los nombres de los parámetros en las llamadas a funciones se ha convertido en obligatorio, incluso para el primero. Entonces, debido a que eso podría causar un gran problema al código escrito en swift 2, puede usar un guión bajo en la declaración para evitar tener que escribir el nombre del parámetro en la llamada. Entonces, en este caso, está diciendo "no me importa el nombre del parámetro externo". Donde el nombre del parámetro externo es lo que llama los parámetros fuera de la función (en llamada) no dentro. Estos nombres de parámetros externos se denominan etiquetas de argumento. http://ericasadun.com/2016/02/09/the-trouble-with-argument-labels-some-thoughts/ ... ¿ve cómo se le dan dos nombres al parámetro? bueno, el primero es hacia dónde va el guión bajo. Espero que esto ayude, y pregunte si aún está confundido.

Answer 2

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") }
    })

De manera similar, al declarar una función que adopta un protocolo o anula un método de superclase, puede usar _ para los nombres de 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 The Swift Programming Language ):

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á del todo relacionada, pero que incluiré ya que (como se señala en los comentarios) parece llevar a la gente aquí: un guión bajo en un identificador, por ejemplo, var _foo , func do_the_thing() , struct Stuff_ , no significa nada en particular Swift, pero tiene algunos usos entre los 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 únicamente 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 subrayado doble ( func __foo() ) acechan en las profundidades de los SDK de Apple: estos son símbolos (Obj) C importados a Swift usando el atributo NS_REFINED_FOR_SWIFT . Apple usa eso cuando quieren hacer una versión "más rápida" 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 que la versión refinada de Swift funcione, por lo que usan __ para mantenerla disponible mientras la ocultan de la mayoría de las herramientas y la documentación.

Answer 3

func divmod(_ a: Int, _ b:Int) -> (Int, Int) {
    return (a / b, a % b)
}

func divmod(a: Int, b:Int) -> (Int, Int) {
    return (a / b, a % b)
}

El _ es un marcador de posición para el nombre del parámetro. En su ejemplo, los llama de manera diferente, en la segunda función, debe escribir el nombre del parámetro a: 1 .

La convención de nombre de la función de Swift es funcName(param1:param2:) , y necesita el _ como marcador de posición para crear el nombre de la función.

En el primer nombre, el nombre es

divmod(_:_:)

Mientras que el segundo es

divmod(a:b:)