Swift Academy · Leçon

Instructions break, continue et étiquetées

Contrôlez le déroulement des boucles avec break, continue et des boucles étiquetées en Swift.

Leçon 4 sur 412 étapes

Instructions break, continue et étiquetées est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Bienvenue

`break` et `continue` vous donnent un contrôle précis sur l’exécution des boucles. Les instructions étiquetées étendent ce contrôle aux boucles imbriquées. Découvrons dans quels cas utiliser chacune de ces possibilités.

break — Quitter la boucle prématurément

`break` termine immédiatement la boucle actuelle : ```swift for i in 1...10 { if i == 5 { break } print(i) } // 1, 2, 3, 4 ``` L’exécution se poursuit avec la première instruction située après la boucle.

continue — Ignorer l’itération actuelle

`continue` ignore le reste de l’itération actuelle et passe à la suivante : ```swift for i in 1...10 { if i % 2 == 0 { continue } print(i) } // 1, 3, 5, 7, 9 ``` Cette instruction est utile pour ignorer les éléments non valides ou inutiles.

break dans les boucles while

`break` fonctionne de la même manière dans les boucles `while` : ```swift var n = 0 while true { n += 1 if n >= 5 { break } } print(n) // 5 ``` Il s’agit du modèle idiomatique de sortie d’une boucle d’événements `while true / break`.

break dans switch — Aucune opération explicite

Dans Swift, un cas `switch` vide provoque une erreur de compilation. Utilisez `break` pour n’effectuer explicitement aucune opération : ```swift switch value { case .ignored: break // intentionally no action default: process(value) } ```

Boucles étiquetées

Étiquetez une boucle avec un identifiant suivi de deux-points : ```swift outerLoop: for row in 0..<3 { for col in 0..<3 { if row == 1 && col == 1 { break outerLoop } print("(\(row),\(col))") } } ``` `break outerLoop` quitte entièrement la boucle *extérieure*.

continue avec des étiquettes

Les étiquettes fonctionnent également avec `continue` : l’exécution passe à l’itération extérieure suivante : ```swift outerLoop: for row in 0..<3 { for col in 0..<3 { if col == 1 { continue outerLoop } print("(\(row),\(col))") } } // skips rest of inner loop when col reaches 1 ```

Combiner where et break

Utilisez une clause `where` pour éviter une instruction `break` explicite lorsque c’est possible : ```swift // Less idiomatic: for n in 1...100 { if n > 10 { break } print(n) } // More idiomatic: for n in (1...100).prefix(10) { print(n) } ``` Privilégiez les alternatives fonctionnelles à l’interruption impérative lorsqu’elles restent lisibles.

Retour anticipé ou break

Dans une fonction, `return` quitte à la fois la boucle et la fonction : ```swift func findFirst(_ target: Int, in array: [Int]) -> Int? { for element in array { if element == target { return element } } return nil } ``` Cette approche est souvent plus claire que d’utiliser `break` et de suivre une variable de résultat.

Éviter break avec first(where:)

De nombreux schémas manuels utilisant `break` peuvent être remplacés par des méthodes de collection : ```swift // break version: var found: Int? for n in numbers { if n > 10 { found = n; break } } // idiomatic: let found = numbers.first { $0 > 10 } ``` La version fonctionnelle est plus courte et exprime directement l’intention.

Vérification rapide

Quelle instruction ignore l’itération **actuelle** et passe à la suivante ?

Réponds-y dans la leçon interactive

Récapitulatif

Points essentiels : • `break` — quitte immédiatement la boucle • `continue` — passe à l’itération suivante • Les boucles étiquetées (`label:`) permettent à `break` et `continue` de cibler une boucle extérieure • Les cas `switch` vides nécessitent un `break` explicite • Privilégiez les alternatives fonctionnelles (`first(where:)`, `prefix`) à `break` lorsque c’est possible Ensuite : les étiquettes d’arguments et les noms de paramètres dans les fonctions.

Gratuit pour commencer

Apprends Swift avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 122
Leçons: 409

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Instructions break, continue et étiquetées » est-elle gratuite ?

Oui — le texte complet de « Instructions break, continue et étiquetées » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Instructions break, continue et étiquetées » ?

Contrôlez le déroulement des boucles avec break, continue et des boucles étiquetées en Swift. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Instructions break, continue et étiquetées » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Boucles for-in avec des intervalles
Boucles while et repeat-while
Parcourir des collections avec for-in
Instructions break, continue et étiquetées

← Retour à Swift Academy