Contrôle de flux

Le contrôle de la boucle

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

Continue

L'instruction continue en Swift sert à interrompre une itération en cours d'une boucle for ou while et passer à la prochaine itération. Cela signifie que le code restant dans la boucle courante est ignorée 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

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

let puzzleInput = "Quel est la phrase mystere ?"
var puzzleOutput = ""
let charactersToRemove: [Character] = ["a", "e", "i", "o", "u", " "]
for character in puzzleInput {
    if charactersToRemove.contains(character) {
        continue
    }
    puzzleOutput.append(character)
}
print(puzzleOutput)
// Cela va afficher : "Qlstlphrsmystr?"

Break

L'instruction break en Swift permet de sortir complètement d'une boucle for ou while. Une fois atteinte, aucune itération supplémentaire de la boucle ne sera effectuée. Le code qui suit la boucle sera alors exécuté.

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)
}

Ce code imprimera les nombres de 1 à 4, car dès que la condition i == 5 est remplie, 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("Value is 1")
case 2:
    print("Value is 2")
case 3:
    print("Value is 3")
    fallthrough
case 4:
    print("Value is 4")
default:
    print("Value is not 1, 2, 3, or 4")
}

// Cela va afficher :
// Value is 3
// Value is 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.

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

switch integerToDescribe {
    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."

Return

L'instruction return en Swift 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.

func addTwoNumbers(a: Int, b: Int) -> Int {
    return a + b
}

let result = addTwoNumbers(a: 2, b: 3)
print(result)
// Cela va afficher : 5

Dans ce code, la fonction addTwoNumbers prend en entrée deux nombres entiers et retourne leur somme. Lorsque l'instruction return a + b est atteinte, la fonction s'arrête et renvoie la somme des nombres à la constante result. La valeur de result sera alors imprimée à l'écran, soit 5. Nous allons découvrir les fonctions dans le prochain chapitre.

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 la gestion des erreurs un peu plus loin dans ce tutoriel.

Déclaration étiquetée

On peut imbriquer des boucles et des instructions conditionnelles dans d'autres boucles et 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

Les déclarations étiquetées en Swift 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 ou pour transmettre le contrôle à une instruction spécifique à l'intérieur d'une fonction.

outerLoop: for i in 1...5 {
    innerLoop: for j in 1...5 {
        if i == 3 && j == 3 {
            break outerLoop
        }
        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 outerLoop est utilisée pour nommer la boucle extérieure, et la déclaration étiquetée innerLoop est utilisée pour nommer la boucle intérieure. Si la condition if i == 3 && j == 3 est remplie, la déclaration break outerLoop est exécutée pour sortir de la boucle extérieure étiquetée. Ainsi, l'exécution de la boucle intérieure s'arrête également et la sortie de la boucle extérieure est transmise au code qui suit les deux boucles.

Condition Guard

Une instruction guard, comme une instruction if, exécute des instructions en fonction de la valeur booléenne d'une expression. Vous utilisez une instruction guard pour exiger qu'une condition soit vraie pour que le code après l'instruction guard soit exécuté. Contrairement à une instruction if, une instruction guard a toujours une clause else.

func greet(person: [String: String]) {
    guard let name = person["name"] else {
        return
    }

    print("Bonjour \(name)!")

    guard let location = person["location"] else {
        print("J'espere qu'il fait beau vers chez toi.")
        return
    }

    print("J'espere qu'il fait beau à \(location).")
}

greet(person: ["name": "Jean"])
// "Bonjour Jean!"
// "J'espere qu'il fait beau vers chez toi."
greet(person: ["name": "Jeanne", "location": "Toulouse"])
// "Bonjour Jeanne!"
// "J'espere qu'il fait beau à Toulouse."

L'instruction return permet de quitter la fonction et de ne pas exécuter le code qui suit à l'interieur de celle-ci. Dans l'exemple ci-dessus, si la constante name ne peut être créée, alors la fonction s'arrête et la lecture du code reprend là ou elle a été appelée.Il en est de même pour la constante location. Cela permet de quitter la fonction à la lecture de la constante location (si elle existe) et de ne pas executer la derniere ligne de code qui afficherait une deuxieme phrase en rapport avec la localisation.

Condition de disponibilité d'API

Vous utilisez une condition de disponibilité dans une instruction if ou guard pour exécuter conditionnellement un bloc de codes, selon que les API que vous souhaitez utiliser sont disponibles au moment de l'exécution.

if #available(iOS 10, macOS 10.12, *) {
    // Use iOS 10 APIs on iOS, and use macOS 10.12 APIs on macOS
} else {
    // Fall back to earlier iOS and macOS APIs
}

La condition de disponibilité ci-dessus spécifie que dans iOS, le corps de l'instruction if s'exécute uniquement dans iOS 10 et versions ultérieures; sous macOS, uniquement sous macOS 10.12 et versions ultérieures. Le dernier argument, *, est obligatoire et spécifie que sur toute autre plate-forme, le corps de if s'exécute sur la cible de déploiement minimal spécifié par votre cible.