Tengo la siguiente clase en Swift 4:
class AClass { var add: (Int) -> Int { return { num in return num + 1 } } func add(_ num: Int) -> Int { return num + 20 } }Tenga en cuenta que la variable y la función tienen el mismo nombre 'agregar'.
Ahora en algún otro lugar tengo este código:
let a = AClass() print(a.add(1))Ejecuté este código y el resultado es 2 (lo que significa que se llama al bloque de la variable).
Así que aquí están las preguntas:
¿El compilador siempre obtiene la variable en lugar de llamar a la función?
¿Hay alguna forma de llamar a la función?
En Swift, los métodos de instancia son funciones curry . Lo que significa que su método de add es en realidad
static func add(_ self: AClass) -> (Int) -> Int Es por eso que la propiedad se elige sobre la función. Llamar AClass.add(a)(1) produce el resultado esperado, se llama a la función.
Ahora, ¿por qué el compilador permite que este nombre coincida en primer lugar? No estoy seguro, pero supongo que tiene que ver con el nombre completo de esas dos entidades. La propiedad es simplemente add , mientras que la función es add(_:) .
Si bien tanto la propiedad como el método comparten el mismo nombre base add , tienen diferentes nombres completos . El nombre completo del método es add(_:) debido a que tiene un parámetro (sin etiqueta de argumento) y el nombre completo de la propiedad es simplemente add . El hecho de que sus nombres completos difieran es lo que les permite sobrecargarse mutuamente.
Si el método no tuviera parámetros, entonces el compilador no habría permitido la sobrecarga, ya que sus nombres completos ahora se add y, por lo tanto, entran en conflicto:
class AClass { var add: () -> Int { return { return 1 } } func add() -> Int { // error: Invalid redeclaration of 'add()' return 2 } }¿El compilador siempre obtiene la variable en lugar de llamar a la función?
Suponiendo que tengan el mismo tipo de función (como en su ejemplo), entonces sí. Hay una regla de clasificación de sobrecarga que favorece las variables sobre las funciones:
// If the members agree on instance-ness, a property is better than a // method (because a method is usually immediately invoked). if (!decl1->isInstanceMember() && decl2->isInstanceMember()) score1 += weight; else if (!decl2->isInstanceMember() && decl1->isInstanceMember()) score2 += weight; else if (isa<VarDecl>(decl1) && isa<FuncDecl>(decl2)) score1 += weight; else if (isa<VarDecl>(decl2) && isa<FuncDecl>(decl1)) score2 += weight;
Para llamar al método, puede referirse a él por su nombre completo, por ejemplo:
let a = AClass() print(a.add(_:)(1)) // 21cambie la definición de su método a esto:
func add(num: Int) -> Int { return num + 20 } aviso, eliminé el _ esto lo obligará a llamar al método de esta manera add(num:) por lo tanto, podrá distinguir entre una llamada de método y una inicialización de variable.
para su pregunta 1.) lo que realmente dice que es una variable es en realidad un cierre.