Les fonctions

Les fonctions vous permettent de définir des morceaux de code réutilisables qui exécutent des fonctionnalités spécifiques. Généralement, les fonctions peuvent recevoir des valeurs pour modifier leur fonctionnement, mais ce n'est pas obligatoire.

Commençons par une fonction simple :

func favoriteAlbum() {
    print("My favorite is Fearless")
}

Si vous écrivez ce code dans votre playgroung, rien ne sera affiché. Et oui, c'est normal. La raison pour laquelle rien n'est affiché est que nous avons placé le message "My favorite is Fearless" dans une fonction appelée favoriteAlbum(), et ce code ne sera pas appelé tant que nous n'aurons pas demandé à Swift d'exécuter la fonction favoriteAlbum(). Pour faire cela, ajoutez cette ligne de code :

favoriteAlbum()

Cette ligne exécute la fonction (ou "l'appelle"), vous verrez donc maintenant le message "My favorite is Fearless".

Comme vous pouvez le constater, vous définissez une fonction en écrivant func, puis le nom de votre fonction, puis des parenthèses, puis un bloc de code délimité par des accolades. Vous appelez ensuite cette fonction en écrivant son nom suivi de parenthèses.

Bien sûr, c’est un exemple stupide : cette fonction fait systématiquement la même chose, il est donc inutile de la créer. Et si nous voulions imprimer un album différent à chaque fois ? Dans ce cas, nous pourrions dire à Swift que nous souhaitons que notre fonction accepte une valeur lorsqu'elle est appelée, puis utilise cette valeur à l'intérieur d'elle.

Faisons cela maintenant :

func favoriteAlbum(name: String) {
    print("My favorite is \(name)")
}

Ce code indique à Swift que nous voulons que la fonction accepte une valeur (appelée un "paramètre"), nommée "name", qui doit être une chaîne de caractères. Nous utilisons ensuite une interpolation de chaîne de caractères pour écrire ce nom d'album préféré directement dans notre message de sortie. Pour appeler cette fonction, vous pouvez par exemple écrire ceci :

favoriteAlbum(name: "Fearless")

Vous vous demandez peut-être encore à quoi ça sert, étant donné que ce n'est toujours qu'une ligne de code. Eh bien, imaginez que nous utilisions cette fonction à 20 endroits différents dans une grosse application, puis votre designer en chef vous invite à changer le message en "I love Fearless so much – it's my favorite!". Voulez-vous vraiment rechercher et modifier les 20 instances dans votre code ? Probablement pas. Avec une fonction, vous la changez une fois et tout se met à jour.

Vous pouvez faire en sorte que vos fonctions acceptent autant de paramètres que vous le souhaitez. Nous allons donc lui faire accepter un nom et une année :

func printAlbumRelease(name: String, year: Int) {
    print("\(name) was released in \(year)")
}

printAlbumRelease(name: "Fearless", year: 2008)
printAlbumRelease(name: "Speak Now", year: 2010)
printAlbumRelease(name: "Red", year: 2012)

Les noms de paramètres des fonctions sont importants et font en réalité partie de la fonction elle-même. Parfois, vous verrez plusieurs fonctions portant le même nom, par exemple handle(), mais avec des noms de paramètres différents pour distinguer les différentes actions.

Noms de paramètres externes et internes

Dans certains cas, vous pouvez souhaiter que les paramètres soient nommés d'une certaine manière lorsqu'une fonction est appelée, mais d'une autre manière à l'intérieur de la fonction elle-même. On utilise cela pour appeler une fonction en utilisant un anglais presque naturel, tout en gardant des noms de paramètres sensés dans la fonction. Cette technique est très fréquemment utilisée en Swift, il est donc important de la comprendre maintenant.

Pour illustrer cela, écrivons une fonction qui affiche le nombre de lettres d’une chaîne de caractères. On peut faire ceci en utilisant la propriété count des chaînes de caractères, et donc écrire ceci :

func countLettersInString(string: String) {
    print("The string \(string) has \(string.count) letters.")
}

Avec cette fonction en place, nous pouvons l'appeler comme ceci :

countLettersInString(string: "Hello")

Bien que cela fonctionne, c’est un peu verbeux. De plus, ce n’est pas le genre de chose que vous diriez à haute voix : "Compte les lettres dans la chaîne de caractères chaîne de caractères 'Hello'".

La solution proposée par Swift consiste à vous permettre de spécifier un nom pour le paramètre lorsque la fonction est appelée et un autre dans la méthode. Pour l'utiliser, il suffit d'écrire le nom du paramètre deux fois, une fois pour son nom externe et une fois pour son nom interne.

Par exemple, nous pourrions nommer le paramètre myString quand il est appelé et str dans la méthode, comme ceci :

func countLettersInString(myString str: String) {
    print("The string \(str) has \(str.count) letters.")
}

countLettersInString(myString: "Hello")  

Vous pouvez également spécifier un underscore _ en tant que nom de paramètre externe, qui indique à Swift qu'il ne doit pas y avoir de nom externe. Par exemple :

func countLettersInString(_ str: String) {
    print("The string \(str) has \(str.count) letters.")
}

countLettersInString("Hello")

Comme vous pouvez le constater, la ligne de code se lit comme une phrase normale : "compte les lettres dans la chaîne de caractères 'Hello'".

Bien qu'il y ait de nombreux cas où utiliser un _ est judicieux, les programmeurs préfèrent généralement en Swift nommer tous leurs paramètres. Et selon vous : pourquoi aurions-nous besoin de dire "chaîne de caractères" dans la fonction - sur quoi d'autre voudrions-nous compter les lettres ?

Ainsi, vous verrez souvent des noms de paramètres externes tels que "in" (dans), "for" (pour) et "with" (avec), et des noms internes plus significatifs. Ainsi, la façon d’écrire cette fonction en Swift est la suivante :

func countLetters(in string: String) {
    print("The string \(string) has \(string.count) letters.")
}

Cela signifie que vous appelez la fonction avec le nom de paramètre "in", ce qui n'aurait aucun sens à l'intérieur de la fonction. Cependant, à l'intérieur de la fonction, le même paramètre s'appelle "string", ce qui est plus utile. Donc, la fonction peut être appelée comme ceci :

countLetters(in: "Hello")

Et cette manière de coder est vraiment typique en Swift : "compte les lettres dans 'Hello'" se lit comme une phrase naturelle, et le code est également clair et concis.

Valeurs retournées

Les fonctions en Swift peuvent retourner une valeur en écrivant -> puis un type de données après la liste des paramètres. Une fois cette opération effectuée, Swift veillera à ce que votre fonction retourne bien une valeur quoi qu'il en soit. Vous vous faites donc à nouveau une promesse sur ce que votre code fait.

Par exemple, écrivons une fonction qui retourne true si un album est de Taylor Swift, ou false si ce n'est pas le cas. Cette fonction doit accepter un paramètre (le nom de l'album à vérifier) et retourner un booléen. Voici le code :

func albumIsTaylor(name: String) -> Bool {
    if name == "Taylor Swift" { return true }
    if name == "Fearless" { return true }
    if name == "Speak Now" { return true }
    if name == "Red" { return true }
    if name == "1989" { return true }

    return false
}

Si vous voulez essayer de mettre en application vos nouvelles connaissances de switch/case, cette fonction s'y prête plutôt bien.

Vous pouvez maintenant l'appeler en passant le nom de l'album et en agissant sur le résultat :

if albumIsTaylor(name: "Red") {
    print("That's one of hers!")
} else {
    print("Who made that?!")
}

if albumIsTaylor(name: "Blue") {
    print("That's one of hers!")
} else {
    print("Who made that?!")
}

Sponsor Hacking with Swift and reach the world's largest Swift community!