#Fonctions

Les fonctions en Swift sont des blocs de code réutilisables qui effectuent une tâche spécifique. Elles sont déclarées avec le mot-clé func. Les fonctions peuvent prendre des paramètres, retourner des valeurs et être utilisées de manière polymorphe.

// Déclaration d'une fonction
func greet(person: String) -> String {
    return "Hello, \(person)!"
}

// Utilisation de la fonction
let greeting = greet(person: "Alice")
print(greeting)  // Affiche "Hello, Alice!"

#Signature de Fonction

Les paramètres d’une fonction sont les valeurs que la fonction attend de recevoir lorsqu’elle est appelée. Ils sont déclarés entre les parenthèses après le nom de la fonction. Chaque paramètre a un nom et un type. Voici un exemple simple :

// Définition d'une fonction avec deux paramètres
func addNumbers(a: Int, b: Int) -> Int {
    return a + b
}

Dans cet exemple, la fonction addNumbers prend deux paramètres de type Int nommés a et b.

#Retour de Fonction

Comme on le voit sur l’exemple précédent, la fonction défini un type de retour avec la flèche -> suivi du type de retour. Si la fonction ne retourne rien, on ne met pas de type de retour.

// Définition d'une fonction sans type de retour
func sayHello() {
    print("Hello!")
}

#Utilisation des Paramètres

Lorsque vous appelez une fonction, vous devez fournir des valeurs correspondantes aux paramètres déclarés. Ces valeurs sont appelées arguments.

let sum = addNumbers(a: 3, b: 5)
print(sum)  // Affiche 8

Les arguments sont fournis dans l’ordre des paramètres de la fonction. Dans cet exemple, la valeur 3 est assignée à a et la valeur 5 à b. La fonction renvoie la somme des deux valeurs.

#Étiquettes de Paramètres

En Swift, chaque paramètre a une étiquette de paramètre et un nom de paramètre. Par défaut, le nom du paramètre est utilisé comme étiquette de paramètre, mais vous pouvez définir des étiquettes de paramètre explicites pour améliorer la clarté du code.

func greet(person name: String, from hometown: String) {
    print("Hello \(name)! Welcome from \(hometown).")
}

greet(person: "Alice", from: "New York")

Dans cet exemple, les étiquettes de paramètre person et from rendent l’appel de la fonction plus expressif.

Utilisez bien les étiquettes de paramètres explicites, elles permettent de rendre le code plus lisible et plus compréhensible. Cela vous sera demandé dans les exercices.

#Paramètres Variadiques

Les paramètres variadiques permettent à une fonction d’accepter un nombre variable d’arguments du même type. Vous déclarez un paramètre variadique en plaçant trois points (...) avant le type du paramètre.

func average(numbers: Double...) -> Double {
    var total = 0.0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}

let avg = average(numbers: 2.0, 4.0, 6.0, 8.0)
print(avg)  // Affiche 5.0

#Paramètres In-Out

Les paramètres in-out permettent à une fonction de modifier une variable existante à l’extérieur de la fonction. Vous déclarez un paramètre in-out en utilisant le mot-clé inout.

func swapValues(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}

var x = 5
var y = 10
swapValues(&x, &y)
print("x: \(x), y: \(y)")  // Affiche "x: 10, y: 5"

#Paramètres avec Valeurs par Défaut

Vous pouvez attribuer des valeurs par défaut aux paramètres d’une fonction. Si la valeur n’est pas fournie lors de l’appel de la fonction, elle utilisera la valeur par défaut.

func greet(person: String, with greeting: String = "Hello") {
    print("\(greeting), \(person)!")
}

greet(person: "Alice")               // Affiche "Hello, Alice!"
greet(person: "Bob", with: "Hi")     // Affiche "Hi, Bob!"

Dans cet exemple, si la valeur de greeting n’est pas fournie, elle prendra la valeur par défaut “Hello”.

Les paramètres jouent un rôle essentiel dans la définition du comportement des fonctions en Swift. Ils permettent de rendre les fonctions flexibles, réutilisables et expressives.

🔗 Pour en savoir plus sur les fonctions en Swift, consultez la documentation sur les fonctions.