Múltiples funciones con el mismo nombre

Soy nuevo en Swift y he pasado por algunos tutoriales y muchos de ellos definen una función más de una vez con el mismo nombre.

Estoy acostumbrado a otros lenguajes de progtwigción donde esto no se puede hacer de lo contrario arroja un error.

Por lo tanto, he comprobado el Manual oficial de Swift y también he verificado la palabra clave de anulación para ver qué puedo obtener de ella, pero aun así no puedo entender el siguiente código:

func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return 10 } func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell { let cell: UITableViewCell = UITableViewCell(style: UITableViewCellStyle.Subtitle, reuseIdentifier: "MyTestCell") cell.textLabel?.text = "Row #\(indexPath.row)" cell.detailTextLabel?.text = "Subtitle #\(indexPath.row)" return cell } 

Por lo que puedo ver, la función tableView se establece en la línea n. ° 1 y en la línea n. ° 5, la única diferencia que noté es que la primera función tableView devuelve un Int y la segunda devuelve un Object (UITableViewCell).

En este caso, veo por el resultado que la segunda función NO anula la primera.

¿Qué significa esto y por qué es posible definir una función más de una vez con el mismo nombre sin anularlo?

Puede definir dos funciones con el mismo nombre si tienen tipos diferentes o si pueden distinguirse por sus tags de parámetros de parámetros externos. El tipo de una función se compone del parámetro Tipos entre paréntesis, seguido de -> , seguido del tipo de retorno. Tenga en cuenta que las tags de argumento NO son parte del tipo de la función. (Pero vea ACTUALIZACIÓN a continuación).

Por ejemplo, las siguientes funciones tienen el mismo nombre y son de tipo (Int, Int) -> Int :

 // This: func add(a: Int, b: Int) -> Int { return a + b } // Is the same Type as this: func add(x: Int, y: Int) -> Int { return x + y } 

Esto producirá un error de tiempo de comstackción, cambiando las tags de a:b: a x:y: no distingue las dos funciones. (Pero vea ACTUALIZACIÓN a continuación).

Usando las funciones del Sr. Web como ejemplos:

 // Function A: This function has the Type (UITableView, Int) -> Int func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int { ... } // Function B: This function has the Type (UITableView, NSIndexPath) -> UITableViewCell func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell { ... } // Function C: This made up function will produce a compile-time error because // it has the same name and Type as Function A, (UITableView, Int) -> Int: func tableView(arg1: UITableView, arg2: Int) -> Int { ... } 

Las funciones A y B anteriores no entran en conflicto porque son de tipos diferentes. La función A y la función C de arriba entran en conflicto porque tienen el mismo tipo. Cambiar las tags de los parámetros no resuelve el conflicto si los tipos siguen siendo los mismos. (Consulte la ACTUALIZACIÓN a continuación).

override es un concepto completamente diferente, y creo que algunas de las otras respuestas lo cubren, así que lo omitiré.

ACTUALIZACIÓN: algo de lo que escribí arriba es incorrecto. Es cierto que las tags de los parámetros de una función no forman parte de su definición de Tipo, pero se pueden usar para distinguir dos funciones que tienen el mismo Tipo, siempre que la función tenga tags externas diferentes para que el comstackdor pueda distinguir qué función a la que intenta llamar cuando lo invoca. Ejemplo:

 func add(a: Int, to b: Int) -> Int { // called with add(1, to: 3) println("This is in the first function defintion.") return a + b } func add(a: Int, and b: Int) -> Int { // called with add(1, and: 3) println("This is in the second function definition") return a + b } let answer1 = add(1, to: 3) // prints "This is in the first function definition" let answer2 = add(1, and: 3) // prints "This is in the second function definition" 

Por lo tanto, el uso de tags externas en una definición de función permitirá que funciones con el mismo nombre y del mismo tipo compilen. Por lo tanto, parece que puede escribir múltiples funciones con el mismo nombre siempre que el comstackdor pueda distinguirlas por sus tipos o por sus tags de firma externas. No creo que las tags internas importen. (Pero espero que alguien me corrija si estoy equivocado).

Estás pensando en la sobrecarga de funciones .

Un extracto de la documentación de Apple aquí :

Puede sobrecargar una función genérica o inicializador al proporcionar diferentes restricciones, requisitos o ambos en los parámetros de tipo en la cláusula de parámetros generics. Cuando llamas a una función o inicializador genérico sobrecargado, el comstackdor usa estas restricciones para resolver qué función sobrecargada o inicializador invocar.

Por ejemplo:

 protocol A { } protocol B { } class A1: A { } class A2: A { } class B1: B { } class B2: B { } func process(value: T) { // process values conforming to protocol A } func process(value: T) { // process values conforming to protocol B } 

o:

 func process(value: Int) { // process integer value } func process(value: Float) { // process float value } 

Esta es solo una confusión típica que podría surgir durante una transición de Objective-C a Swift. Deberías leer sobre los nombres de los parámetros aquí .

En Swift, como en Objective-C, los parámetros de una función forman parte de la definición. No hay dos funciones llamadas tableView , hay una función llamada tableView(tableView:, numberOfRowsInSection:) y otra llamada tableView(tableView:, cellForRowAtIndexPath:)

Las funciones no son lo mismo, son diferentes. Porque no toman los mismos argumentos y devuelven cosas diferentes. Esta es la explicación simple si no entiendes los generics.