Contrôle de Flux

Break

L'instruction break en Swift est utilisée pour interrompre immédiatement une boucle ou un bloc switch. Elle permet de sortir prématurément d'une structure de contrôle.

Utilisation de break dans une boucle :

for i in 1...10 {
    if i == 5 {
        break  // Interrompt la boucle lorsque i vaut 5
    }
    print(i)
}

Résultat :

1
2
3
4

Dans cet exemple, la boucle s'arrête lorsque i atteint 5, et les valeurs de i supérieures à 4 ne sont pas affichées.

Utilisation de break dans un switch :

break est également implicite dans un switch en Swift, car une fois qu'une case est exécutée, le switch se termine automatiquement. Cependant, il peut être explicitement utilisé pour interrompre un bloc switch sans exécuter d'autres instructions dans la case.

let number = 3
switch number {
case 1:
    print("Un")
case 2:
    print("Deux")
case 3:
    print("Trois")
    break  // Optionnel ici car le case se termine naturellement
default:
    print("Autre")
}

Continue

L'instruction continue permet de passer à l'itération suivante d'une boucle, en sautant le reste du corps de la boucle pour l'itération courante.

Exemple de continue dans une boucle :

for i in 1...10 {
    if i % 2 == 0 {
        continue  // Ignore les nombres pairs
    }
    print(i)
}

Résultat :

1
3
5
7
9

Dans cet exemple, chaque fois que i est un nombre pair, l'instruction continue est exécutée, ce qui fait sauter l'affichage de ce nombre et passer directement à l'itération suivante.

Fallthrough

Contrairement à d'autres langages comme C, Swift ne permet pas par défaut de "tomber" à travers les cases d'un switch. L'instruction fallthrough force l'exécution de la case suivante dans un switch, même si elle ne correspond pas à la valeur.

Exemple d'utilisation de fallthrough :

let number = 2
switch number {
case 1:
    print("Un")
case 2:
    print("Deux")
    fallthrough  // Passe à la case suivante
case 3:
    print("Trois")
default:
    print("Autre")
}

Résultat :

Deux
Trois

Dans cet exemple, même si number vaut 2, la case 3 est également exécutée à cause du fallthrough.

Return

return est utilisé dans une fonction ou une méthode pour interrompre l'exécution de la fonction et retourner une valeur (ou rien dans le cas d'une fonction sans retour).

Exemple de return :

func greet(person: String) -> String {
    if person.isEmpty {
        return "Bonjour, inconnu !"  // Arrête la fonction ici si la chaîne est vide
    }
    return "Bonjour, \(person) !"
}
let message = greet(person: "")
print(message)  // Affiche "Bonjour, inconnu !"

Ici, return arrête l'exécution de la fonction dès qu'il est rencontré, même si du code existe après.

Throw

throw est utilisé pour lever une erreur dans une fonction qui peut générer des exceptions. Cela interrompt l'exécution normale de la fonction et passe à la gestion des erreurs.

Exemple de throw :

enum NetworkError: Error {
    case noInternet
}
func fetchData() throws {
    throw NetworkError.noInternet  // Lève une erreur
}
do {
    try fetchData()
} catch {
    print("Erreur : Pas d'internet")  // Gestion de l'erreur
}

Guard

guard est une instruction utilisée pour vérifier qu'une condition est vraie. Si elle est fausse, l'exécution est interrompue avec un return, break, ou continue. C'est une manière élégante de sortir tôt d'une fonction ou d'une boucle si les conditions ne sont pas respectées.

Exemple de guard :

func validateInput(input: String?) {
    guard let validInput = input else {
        print("Entrée invalide")
        return  // Sort de la fonction si input est nil
    }
    print("Entrée valide : \(validInput)")
}

Ici, si input est nil, la fonction s'arrête immédiatement grâce à guard.

Defer

L'instruction defer est utilisée pour reporter l'exécution d'un bloc de code jusqu'à la fin de la portée actuelle, que ce soit en quittant une fonction normalement ou en cas d'erreur.

Exemple de defer :

func example() {
    defer {
        print("Cette ligne sera exécutée à la fin")
    }
    print("Ligne 1")
    print("Ligne 2")
}
example()

Résultat :

Ligne 1
Ligne 2
Cette ligne sera exécutée à la fin

defer garantit que le code placé dans son bloc sera exécuté juste avant que la fonction ne se termine, ce qui est utile pour nettoyer les ressources (comme fermer des fichiers ou des connexions réseau).

Labeled Statements

Dans Swift, vous pouvez étiqueter des boucles ou des structures de contrôle, ce qui permet de contrôler précisément où un break ou continue doit s'appliquer dans les boucles imbriquées.

Exemple d'utilisation des étiquettes :

outerLoop: for i in 1...5 {
    for j in 1...5 {
        if i == 3 && j == 3 {
            break outerLoop  // Quitte la boucle extérieure
        }
        print("\(i), \(j)")
    }
}

Résultat :

1, 1
1, 2
1, 3
1, 4
1, 5
2, 1
2, 2
2, 3
2, 4
2, 5
3, 1
3, 2

Ici, lorsque i et j valent 3, le break outerLoop interrompt la boucle externe (étiquetée outerLoop), ce qui permet de contrôler précisément où arrêter l'exécution.