Contrôle de flux en Swift

Contrôle des boucles

• continue : Pour interrompre une itération en cours et passer à la prochaine
• break : Pour sortir complètement d'une boucle
• fallthrough : Pour forcer l'exécution du code à la prochaine case d'un bloc switch
• return : Pour retourner une valeur d'une fonction et arrêter son exécution
• throw : Pour la gestion des erreurs

Continue

L'instruction continue en Swift sert à interrompre l'itération en cours d'une boucle for ou while et passer directement à la prochaine itération. Cela signifie que le code restant dans la boucle courante est ignoré et la boucle recommence à partir de l'itération suivante :

for i in 1...10 {
    if i % 2 == 0 {
        continue
    }
    print(i)
}

// Cela va afficher : 1, 3, 5, 7, 9

Dans l'exemple ci-dessus, la boucle fait un premier tour, soit une première itération. La variable i vaut alors 1 et la condition n'est donc pas remplie. L'instruction print est exécutée et cela affiche : 1. Au deuxième tour de boucle, ou à la deuxième itération, la variable i vaut cette fois 2 et la condition est donc remplie car 2 divisé par 2 a pour reste 0. Le code entre accolades sera exécuté. L'instruction continue indique à la boucle d'interrompre l'itération en cours pour passer à la suivante. La commande print n'est alors pas prise en compte. Et ainsi de suite jusqu'à ce que la variable i soit égale à 10.

Ce code imprimera donc les nombres impairs de 1 à 10, car à chaque itération où la variable i a pour valeur un nombre pair, l'instruction continue sera appelée et l'itération courante sera interrompue, passant directement à la prochaine itération.

Voici un autre exemple, un peu plus compliqué cette fois :

let phraseEntree = "Quel est la phrase mystere ?"
var phraseSortie = ""
let voyellesASupprimer: [Character] = ["a", "e", "i", "o", "u", " "]
for lettre in phraseEntree {
    if voyellesASupprimer.contains(lettre) {
        continue
    }
    phraseSortie.append(lettre)
}

print(phraseSortie)
// Cela va afficher : "Qlstlphrsmystr?"

L'exemple ci-dessus va retirer toutes les voyelles de la chaine de caractères contenus dans la variable phraseEntree .

Pour commencer, nous avons une constante contenant la phrase d'entrée nommée phraseEntree, une variable qui contiendra la phrase de sortie nommée phraseSortie et une autre constante nommée voyellesASupprimer qui contient les caractères à supprimer. Cette dernière constante est d'un type particulier : C'est un tableau, ou array. Nous découvrirons justement ce type dans le prochain chapitre.

Nous allons ensuite déclarer une boucle for qui va itérer chaque caractère de la phrase d'entrée, espaces y compris. À l'intérieur de cette boucle, une condition if testera si le caractère étudié fait partie de la liste des voyelles à supprimer. Si c'est le cas, l'instruction continue interrompra l'itération pour passer à la suivante. Sinon, le caractère étudié sera ajouté à la phrase de sortie grâce à la méthode append. Ainsi, uniquement les caractères non "interdits" seront ajoutés un par un à la variable phraseSortie

Break

En Swift, l'instruction break permet de sortir complètement d'une boucle for ou d'une boucle while. Une fois atteinte, aucune itération supplémentaire de la boucle ne sera effectuée.

L'instruction break met immédiatement fin à l'exécution d'une instruction de flux de contrôle entière.

for i in 1...10 {
    if i == 5 {
        break
    }
    print(i)
}

Le code ci-dessus imprimera les nombres de 1 à 4 car dès que la condition i == 5 est remplie (true), l'instruction break sera appelée et la boucle for sera interrompue.

Fallthrough

L'instruction fallthrough en Swift permet de forcer l'exécution du code dans la prochaine case d'un bloc switch. Par défaut, une fois qu'une case a été sélectionnée dans un bloc switch, aucun code supplémentaire n'est exécuté après cela. Cependant, en utilisant l'instruction fallthrough, le code dans la case suivante sera également exécuté.

let value = 3

switch value {
case 1:
    print("La valeur est 1")
case 2:
    print("La valeur est 2")
case 3:
    print("La valeur est 3")
    fallthrough
case 4:
    print("La valeur est 4")
default:
    print("La valeur est 1, 2, 3 ou 4")
}

// Cela va afficher :
// La valeur est 3
// La valeur est 4

Lorsque value est égal à 3, la case correspondante sera sélectionnée et le code sera exécuté. L'instruction fallthrough forcera ensuite l'exécution du code dans la case 4 puis quittera la condition switch.

Prenons un autre exemple, plus compliqué cette fois car votre niveau de compréhension vous permet de faire de plus grandes choses maintenant :

let entier = 5
var description = "Le chiffre \(entier) est"

switch entier {
    case 2, 3, 5, 7, 11, 13, 17, 19:
        description += " un nombre premier, et aussi"
        fallthrough
    default:
        description += " un entier."
}

print(description)
// Cela va afficher : 
// Le chiffre 5 est un nombre premier, et aussi un entier.

Que se passe-t-il dans la condition switch ? C'est tout simple, le premier cas liste les nombres premiers. La variable entier ayant pour valeur 5 remplit donc cette condition. Du texte sera alors ajouté à la variable description et l'instruction fallthrough va forcer l'exécution du cas suivant. Le cas default sera donc lui aussi exécuté.

Return

L'instruction return permet de retourner une valeur d'une fonction et d'arrêter son exécution. Une fois atteinte, le reste du code dans la fonction n'est plus exécuté et le contrôle est renvoyé au code appelant la fonction. Nous reviendrons sur ce mot-clé en détail dans le chapitre sur les fonctions Swift.

Throw

L'instruction throw en Swift permet de lancer une erreur. Lorsqu'une erreur est lancée, le code suivant ne sera pas exécuté et le contrôle sera renvoyé au code appelant la fonction dans laquelle l'erreur a été lancée. Les erreurs en Swift peuvent être gérées à l'aide d'un bloc do-catch. Nous aborderons également la gestion des erreurs dans quelques chapitres.

Déclaration étiquetée

On peut imbriquer des boucles et des instructions conditionnelles dans d'autres boucles ou instructions conditionnelles pour créer des structures de flux de contrôles complexes. Cependant, les boucles et les instructions conditionnelles peuvent toutes deux utiliser l'instruction break pour mettre fin prématurément à leur exécution. Par conséquent, il est parfois utile d'être explicite sur la boucle ou l'instruction conditionnelle que vous souhaitez terminer.

Pour plus de lisibilité, vous pouvez marquer une instruction de boucle ou une instruction conditionnelle avec une étiquette d'instruction. Pour ce faire, écrivez le nom de la boucle suivi de deux points juste avant la déclaration de la boucle.

nomDeLaBoucle: for i in 1...10 {
    print(i)
}

En Swift, les déclarations étiquetées permettent de nommer une instruction spécifique dans le code pour y faire référence ultérieurement. Cela peut être utile pour sortir d'une boucle imbriquée par exemple :

boucleExterieure: for i in 1...5 {

    boucleInterieure: for j in 1...5 {
        if i == 3 && j == 3 {
            break boucleExterieure
        }
        print("\(i), \(j)")
    }

}

// Cela va afficher :
// 1, 1
// 1, 2
// 1, 3
// 1, 4
// 1, 5
// 2, 1
// 2, 2
// 2, 3
// 2, 4
// 2, 5
// 3, 1
// 3, 2

Dans le code ci-dessus, la déclaration étiquetée boucleExterieure est utilisée pour nommer la boucle extérieure, et la déclaration étiquetée boucleInterieure est utilisée pour nommer la boucle intérieure.

Si la condition i == 3 && j == 3 est remplie (true), la déclaration break boucleExterieure est exécutée pour sortir de la boucle extérieure. Ainsi, l'exécution de la boucle intérieure s'arrête également.

J'espère que vous mesurez les progrès que vous avez fait et tout le travail accompli jusqu'ici. Encouragez-vous en le partageant sur les réseaux sociaux, soyez fier de votre travail ! N'oubliez pas de faire les exercices disponibles en fin de chapitre, ils consolideront votre apprentissage. See you to the next chapitre.

for i in 1...20 {
    if i % 3 == 0 {
        continue
    }
    print(i)
}