Les Fonctions en Swift

Les fonctions sont des blocs de code organisés pour accomplir une tâche précise. Chaque fonction reçoit un nom qui indique sa fonction, ce nom étant utilisé pour "appeler" la fonction et exécuter sa tâche selon les besoins.

Définir et Appeler une Fonction

Il y a trois éléments essentiels qui définissent une fonction. En premier, le nom de la fonction, utilisé pour l'appeler. Ensuite, les paramètres que la fonction accepte, qui représentent les entrées de la fonction. Enfin, il y a le type de retour de la fonction, qui désigne le type de données que sera le résultat de la fonction. Le nom de la fonction doit décrire son comportement.

Voici un exemple de la syntaxe des fonctions en Swift :

func saluer(nom: String) -> String { 
    let salutation = "Bonjour, " + nom + "!"
    return salutation
}

Dans cet exemple, la fonction saluer prend un paramètre de type String appelé nom, et retourne une String qui est "Bonjour" concaténé au nom passé. La fonction saluer() est appelée avec la syntaxe suivante :

print(saluer(nom: "Anna")) // Affiche "Bonjour, Anna!"

Paramètres Multiples

Les fonctions peuvent accepter plusieurs paramètres d’entrée, qui doivent être séparés par des virgules lors de l’appel. Par exemple, cette fonction reçoit deux nombres et retourne leur somme:

func somme(x: Int, y: Int) -> Int {
    return x + y
}
let resultat = somme(x: 1, y: 2)
print(resultat) // Affiche: 3

Retourner Plusieurs Valeurs

On peut utiliser un tuple comme type de retour d'une fonction pour permettre plusieurs valeurs de retour. Chaque valeur dans les parenthèses doit être étiquetée et avoir un type dans la définition de la fonction. Voici un exemple qui prend un tableau d'entiers et retourne le plus petit et le plus grand nombre :

func minMax(tableau: [Int]) -> (NombreMin: Int, NombreMax: Int) {
    var NombreMin = tableau[0]
    var NombreMax = tableau[0]
    if tableau.isEmpty { 
        return (0, 0)
    } else { 
        for value in tableau { 
            if value < NombreMin { 
                NombreMin = value 
            } else if value > NombreMax { 
                NombreMax = value 
            }
        }
    }
    return (NombreMin, NombreMax)
}

On peut ensuite accéder aux valeurs du tuple avec la syntaxe des points:

let valeursRange = minMax(tableau: [12, 11, -2, 327, 230, 95])
print("Le nombre minimum est \(valeursRange.NombreMin) et le nombre maximum est \(valeursRange.NombreMax)") // Affiche "Le nombre minimum est -2 et le nombre maximum est 327"

Comment Omettre les Étiquettes d’Argument

Pour éviter d'avoir une étiquette d'argument, on peut utiliser _ au lieu d'une étiquette d'argument explicite pour ce paramètre:

func trouverDifferenceEntre(_ a: Int, _ b: Int) -> Int {
    return a - b
}
print(trouverDifferenceEntre(6, 4)) // Affiche: 2

Retour Implicite

Si le corps de la fonction se compose d'une seule expression, la fonction retourne implicitement la valeur de cette expression. Par exemple :

func saluer(nom: String) -> String {
    "Bonjour, " + nom + "!"
}

Paramètres par Défaut

Un paramètre par défaut est celui auquel une valeur est assignée dans la définition de la fonction :

func tempsPourFinirLivre(nombreMots: Double, motsParMin: Double = 200) -> Double {
    let totalMinutes = nombreMots / motsParMin
    return totalMinutes / 60
}
print("\(tempsPourFinirLivre(nombreMots: 93000)) heures") // Affiche: 7.75 heures

Utiliser des Paramètres Variadiques

Les paramètres variadiques acceptent zéro ou plusieurs valeurs d'un type spécifié. On les déclare en insérant trois points (...) après le type du paramètre. L'exemple ci-dessous calcule la somme de tous les éléments d'une liste de nombres de n'importe quelle longueur :

func sommeTotale(_ nombres: Int...) -> Int {
    var total: Int = 0
    for nombre in nombres {
        total += nombre
    }
    return total
}
sommeTotale(1, 2, 3, 4, 5) // retourne 15, qui est la somme des nombres

Fonctions avec des Paramètres In-Out

Pour modifier la valeur passée pour un certain argument, on peut utiliser un argument inout. Un paramètre inout est indiqué avec le mot-clé inout dans la définition de la fonction, et quand la fonction est appelée, son argument doit être précédé d'un &.

func decrementer(_ a: inout Int) {
    a -= 1
}

Cet exemple réduit une valeur passée de 1.

var nombre = 3
incrementer(&nombre)
print(nombre) // Affiche 2

L'exemple ci-dessus montre que la valeur originale de nombre est modifiée par la fonction decrementer(), même si la variable a été définie en dehors de la fonction. Note : Les paramètres inout ne sont pas identiques à un retour de valeur d'une fonction. L'exemple decrementer() n'a pas de type de retour, mais il modifie toujours la valeur de nombre. Les paramètres inout offrent une alternative pour qu'une fonction ait un effet à l'extérieur du corps de la fonction.