Swift 函数重载

En este artículo, aprenderás sobre la sobrecarga de funciones, cuándo se necesita y cómo sobrecargar ejemplos.

con el mismo nombre pero con diferentes parámetrosfuncionesllamada función sobre cargada.

¿Por qué necesitamos sobrecarga de funciones?

Imagina que estás desarrollando un juego de disparos, donde el jugador puede atacar a los enemigos con cuchillos, espadas y pistolas. Tu solución para la función de ataque podría ser definir la operación como una función:

func attack() {
　　　　//..
　　　　print("atacar con cuchillo")
}
func attack() {
　　　　//..
　　　　print("用剑攻击")
}
func attack() {
　　　　//..
　　　　print("atacar con pistola")
}

Pero, cuando intentes ejecutar el programa anterior, recibirás errores de compilación en Swift, como 'attack()' declarado previamente aquí。但是，另一种可能的解决方案 podría ser definir nombres de función diferentes para funciones específicas, como se muestra a continuación:

struct Knife {
}
struct Gun {
}
struct Blade {
}
func attackUsingKnife(weapon: Knife) {
　　　　//..
　　　　print("atacar con cuchillo")
}
func attackUsingBlade(weapon: Blade) {
　　　　//..
　　　　print("用剑攻击")
}
func attackUsingGun(weapon: Gun) {
　　　　//..
　　　　print("atacar con pistola")
}

Si no sabes qué es struct, no te preocupes. Ahora, simplemente piensa en él como algo que se crea en la programación para crear objetos físicos, por lo que estás creando un cuchillo, una pistola y una espada.

El único problema con esta solución es que necesitas recordar el nombre de la función para llamar a la operación de ataque específica. Del mismo modo, a medida que sube de nivel, el jugador puede tener otras funciones para atacar usando bombas, granadas, escopetas, etc.

Crear funciones con nombres diferentes es tiempo consumidor y aumenta el costo de recordar los nombres de las funciones para llamarlas. En resumen, no es muy intuitivo.

Si se puede crear diferentes funciones con el mismo nombre para cada tipo de arma, sería mejor. De esta manera, recordar un nombre de función sería suficiente y no tendrías que preocuparte por los nombres de las funciones de otras armas.

¿Qué es la sobrecarga de funciones?

El proceso que acabamos de describir se llama sobrecarga de funciones. Según la definición, el proceso de crear dos o más funciones con el mismo nombre pero con una cantidad o tipo de parámetros diferentes se llama sobrecarga de funciones.

Vamos a ver esto en el siguiente ejemplo:

Ejemplo1：函数重载

struct Knife {
}
struct Gun {
}
struct Blade {
}
func attack(with weapon: Knife) {
　　　　print("atacar con cuchillo")
}
func attack(with weapon: Gun) {
　　　　print("atacar con pistola")
}
func attack(with weapon: Blade) {
　　　　print("用剑攻击")
}
attack(with: Gun())
attack(with: Blade())
attack(with: Knife())

Cuando ejecute el programa anterior, la salida será:

用枪攻击
用剑攻击
用刀攻击

在以上程序中，我们创建了三个具有相同名称的不同函数attack。但是，它接受不同的参数类型。这样，记住 attack 名称即可调用函数。

• 调用 attack(with: Gun()) 将触发函数内部的 func attack(with weapon:Gun) 语句。

• 调用 attack(with: Blade()) 将触发函数内部的 func attack(with weapon:Blade) 语句。

• 调用 attack(with: Knife()) 将触发函数内部的 func attack(with weapon:Knife) 语句。

Ejemplo2：基于不同参数类型的函数重载

func output(x: Int) {
　　　　print("int值是 (x)")
}
func output(x: String) {
　　　　print("字符串值是 (x)")
}
output(x:　2)
output(x: "Swift")

Cuando ejecute el programa anterior, la salida será:

int值是　2
字符串值是 Swift

在上面的程序中，我们有两个具有相同名称和相同数量参数的函数output()。但是，第一个output()函数将整数作为参数，第二个output()函数将String参数作为参数。

与示例1类似，

• 调用 output(x: 2) 会触发函数内部的 func output(x:Int) 语句

• 调用 output(x: "Swift") 会触发函数内部的 func output(x:String) 语句。

Ejemplo3：基于不同数量参数的函数重载

func output() {
　　　　print("¡Buenos días!")
}
func output(text: String) {
　　　　print(text)
}
func output(text: String, num: Int) {
　　　　print("(text)(num)!")
}
output()
output(text: "¡Buenas noches!")
output(text1: "Buen N", num:　8)

Cuando ejecute el programa anterior, la salida será:

¡Buenos días!
¡Buenas noches!
Buenas noches!

En el programa anterior, la función output() se ha sobrecargado según la cantidad de parámetros.

El primer output() sin parámetros, el segundo output() con un parámetro: String, el tercer output() con dos parámetros: String y Int.

Vamos a intentar sobrecargar cambiando el nombre de los parámetros, pero manteniendo las etiquetas de parámetros inmutables, como se muestra a continuación:

Ejemplo4：函数重载 con etiquetas de parámetros idénticas

func output(value text: String) {
　　　　print(text)
}
func output(value num: Int) {
　　　　print(num)
}
output(value:　2)
output(value: "Hola")

Cuando ejecute el programa anterior, la salida será:

2
Hola

Como puede ver, en el programa anterior, se puede usar la misma etiqueta de parámetro para funciones sobrecargadas. Sin embargo, según los requisitos de sobrecarga, debe tener una cantidad diferente de parámetros o parámetros de diferentes tipos.