0Pricing
Swift Academy · Leçon

Boucles while et repeat-while

Utilisez des boucles conditionnelles et garantissez au moins une exécution avec repeat-while.

Boucles while et repeat-while est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 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

Lorsque le nombre d'itérations n'est pas connu à l'avance, les boucles `while` et `repeat-while` sont le bon choix. Voyons quand et comment utiliser chacune d'elles.

La boucle while

Une boucle `while` évalue sa condition *avant* chaque itération : ```swift var count = 0 while count < 5 { print(count) count += 1 } // prints 0, 1, 2, 3, 4 ``` Si la condition est fausse au départ, le corps ne s'exécute jamais.

La boucle repeat-while

Une boucle `repeat-while` évalue sa condition *après* chaque itération, ce qui garantit au moins une exécution : ```swift var x = 10 repeat { print(x) x -= 3 } while x > 0 // prints 10, 7, 4, 1 ```

while ou repeat-while

Utilisez `while` lorsque le corps peut ne pas devoir s'exécuter. Utilisez `repeat-while` lorsque le corps doit s'exécuter au moins une fois : ```swift // Reading input until valid — must try at least once: repeat { input = readLine() ?? "" } while input.isEmpty ```

Boucles infinies avec while true

Une boucle `while true` s'exécute indéfiniment jusqu'à ce qu'un `break` soit rencontré — c'est un schéma courant pour les boucles d'événements : ```swift while true { let event = nextEvent() if event == .quit { break } handleEvent(event) } ``` Assurez-vous toujours qu'une condition de sortie puisse être atteinte.

Exemple de compte à rebours

```swift var countdown = 5 while countdown > 0 { print("\(countdown)...") countdown -= 1 } print("Liftoff!") ``` Il s'agit d'un schéma classique de boucle while : décrémenter jusqu'à ce que la condition devienne fausse.

Éviter les boucles infinies

Erreurs courantes qui créent des boucles infinies : ```swift var i = 0 while i < 5 { print(i) // forgot i += 1 ← infinite loop! } ``` Vérifiez toujours que la variable de boucle est mise à jour et que la condition finira par devenir fausse.

while avec liaison facultative

Combinez `while` avec une liaison facultative pour traiter une séquence jusqu'à obtenir nil : ```swift var items: [Int] = [1, 2, 3] while let value = items.first { print(value) items.removeFirst() } ``` Ce schéma est pratique pour consommer des collections de manière destructive.

Exemple de boucle de jeu

```swift var lives = 3 var gameOver = false while !gameOver { let hit = Bool.random() if hit { lives -= 1 } if lives == 0 { gameOver = true } } print("Game Over") ``` Les véritables boucles de jeu utilisent ce schéma pour continuer jusqu'à atteindre une condition terminale.

Boucles while imbriquées

Les boucles while peuvent être imbriquées — c'est courant dans l'analyse syntaxique ou les algorithmes matriciels : ```swift var row = 0 while row < 3 { var col = 0 while col < 3 { print("(\(row),\(col))", terminator: " ") col += 1 } print(); row += 1 } ```

Vérification rapide

Quelle boucle garantit que son corps s'exécute **au moins une fois** ?

Récapitulatif

Points essentiels : • `while condition { }` — vérifie la condition avant chaque exécution ; peut ne jamais s'exécuter • `repeat { } while condition` — vérifie la condition après ; s'exécute au moins une fois • `while true { ... break }` — schéma de boucle d'événements • Assurez-vous toujours que la variable de boucle progresse vers la terminaison • Combinez `while` avec une liaison facultative pour parcourir proprement une séquence Suite : parcourir des collections avec for-in.

Questions Fréquemment Posées

La leçon « Boucles while et repeat-while » est-elle gratuite ?

Oui — le texte complet de « Boucles while et repeat-while » 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 « Boucles while et repeat-while » ?

Utilisez des boucles conditionnelles et garantissez au moins une exécution avec repeat-while. 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 2 sur 4.

Combien de temps prend la leçon « Boucles while et repeat-while » ?

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

  1. Boucles for-in avec des intervalles
  2. Boucles while et repeat-while
  3. Parcourir des collections avec for-in
  4. Instructions break, continue et étiquetées
← Retour à Swift Academy