Fonctions multiples avec le même nom

vous êtes autorisé à définir deux fonctions avec le même nom si elles ont des Types différents, ou si elles peuvent être distinguées par leurs étiquettes d'arguments externes. Le Type d'une fonction est composé des types de paramètres entre parenthèses, suivi de ->, suivi du Type de retour. Notez que les étiquettes d'argument ne font pas partie du Type de la fonction. (mais voir Mise à jour ci-dessous.)

par exemple, les fonctions suivantes ont le même nom et sont de Type (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
}

cela produira une erreur de compilation-changer les étiquettes de a:b:x:y: ne distingue pas les deux fonctions. (mais voir Mise à jour ci-dessous.)

à l'Aide de M. Web de fonctions à titre d'exemple:

// 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 { ... }

les fonctions A et B ci-dessus ne sont pas en conflit parce qu'elles sont de Types différents. la Fonction et de la Fonction C au-dessus de conflit parce qu'ils ont le même Type. Changer les étiquettes de paramètre ne résolvent pas le conflit si les Types restent les mêmes. (voir la mise à jour ci-dessous.)

override est un concept tout à fait différent, et je pense que certaines des autres réponses le couvrent, donc je vais sauter.

mise à jour: une partie de ce que j'ai écrit ci-dessus est incorrecte. Il est vrai que les étiquettes de paramètres d'une fonction ne font pas partie de sa définition de Type, mais elles peuvent être utilisées pour distinguer deux fonctions qui ont le même Type, à condition que la la fonction a des étiquettes externes qui sont différentes de sorte que le compilateur peut dire quelle fonction vous essayez d'appeler quand vous l'invoquez. Exemple:

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"

ainsi, l'utilisation d'étiquettes externes dans une définition de fonction permettra de compiler des fonctions avec le même nom et du même type. Donc, il semble que vous pouvez écrire plusieurs fonctions avec le même nom aussi long que le compilateur peut les distinguer par leurs types ou externe étiquettes de signature. Je ne pense pas qu'interne les étiquettes de la matière. (Mais j'espère que quelqu'un me corrigera si je me trompe.)