Lua Academy · Leçon

Boucles while et repeat-until

Utilisez while et repeat-until pour effectuer des itérations guidées par des conditions.

Boucles while et repeat-until est une leçon Lua 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 Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

La boucle while

Une boucle while répète son corps tant que la condition est considérée comme vraie. La condition est vérifiée avant chaque itération. Si la condition est initialement fausse, le corps n’est jamais exécuté. Assurez-vous toujours que la boucle progresse vers sa condition de sortie afin d’éviter les boucles infinies.

local count = 1

while count <= 5 do
  print(count)
  count = count + 1
end
-- prints 1 through 5

Boucle repeat-until

La boucle repeat...until est l’équivalent Lua de do-while. Le corps s’exécute au moins une fois et la condition est vérifiée après chaque itération. La boucle s’arrête lorsque la condition devient vraie (à l’inverse de while). Les variables déclarées dans le corps sont visibles dans la condition.

local n = 1

repeat
  print(n)
  n = n * 2
until n > 100
-- prints: 1, 2, 4, 8, 16, 32, 64

Boucles infinies avec break

Utilisez while true do pour les boucles d’événements ou les mécanismes de nouvelle tentative, avec break pour sortir lorsqu’une condition est remplie. Ce modèle est courant dans les boucles principales de jeux et les serveurs réseau qui s’exécutent en continu.

local attempts = 0
local MAX = 3

while true do
  attempts = attempts + 1
  print("Attempt " .. attempts)
  if attempts >= MAX then
    print("Max attempts reached")
    break
  end
end

Compte à rebours avec while

Les boucles while conviennent tout aussi bien pour compter à rebours. L’essentiel est de mettre à jour la variable de manière à ce que la condition de sortie soit finalement satisfaite. Oublier de mettre à jour le compteur est une cause fréquente de boucles infinies.

local i = 10

while i > 0 do
  io.write(i .. " ")
  i = i - 1
end
print()   -- newline
-- output: 10 9 8 7 6 5 4 3 2 1

repeat-until pour valider les entrées

Le modèle repeat-until est idéal pour valider les entrées : demandez une valeur, puis vérifiez-la. Dans ce modèle, le corps s’exécute toujours au moins une fois, ce qui correspond au déroulement naturel « demander, puis valider ».

-- Simulated input validation
local inputs = {-1, 0, 5}  -- pretend user input
local idx = 0
local value

repeat
  idx = idx + 1
  value = inputs[idx]
  print("Got: " .. value)
until value > 0

print("Valid value: " .. value)  -- 5

Les variables de boucle sont locales

Les variables déclarées avec local dans le corps d’une boucle sont recréées à chaque itération. C’est important lorsque vous capturez des variables de boucle dans des fermetures : chaque fermeture capture sa propre copie. Les variables déclarées en dehors de la boucle persistent d’une itération à l’autre.

local callbacks = {}

for i = 1, 3 do
  local captured = i        -- local per iteration
  callbacks[i] = function() return captured end
end

print(callbacks[1]())  -- 1
print(callbacks[2]())  -- 2
print(callbacks[3]())  -- 3

Modèle de l’accumulateur

Un cas d’utilisation courant des boucles while consiste à accumuler un résultat. Les sommes, les produits, la concaténation de chaînes et la construction de tables suivent tous le modèle de l’accumulateur : initialiser avant la boucle, mettre à jour à l’intérieur, puis utiliser le résultat après.

local numbers = {3, 1, 4, 1, 5, 9, 2, 6}
local sum = 0
local i = 1

while i <= #numbers do
  sum = sum + numbers[i]
  i = i + 1
end

print("Sum:", sum)     -- 31
print("Avg:", sum / #numbers)  -- 3.875

Boucles imbriquées

Les boucles peuvent être imbriquées. Chaque boucle possède son propre compteur. Utilisez des noms de variables explicites pour plus de clarté. L’instruction break ne sort que de la boucle englobante la plus interne ; pour sortir de plusieurs niveaux, vous aurez peut-être besoin d’une variable indicatrice ou de goto (Lua 5.2 ou version ultérieure).

local found = false
local target = 6

local i = 1
while i <= 3 and not found do
  local j = 1
  while j <= 3 do
    if i * j == target then
      print(i .. " * " .. j .. " = " .. target)
      found = true
      break
    end
    j = j + 1
  end
  i = i + 1
end

goto pour sortir de plusieurs niveaux

Lua 5.2 ou version ultérieure a introduit goto, qui permet de sauter à une position étiquetée. Bien que généralement déconseillé, il peut être pertinent pour sortir proprement de boucles imbriquées sans variable indicatrice. Les étiquettes se définissent avec ::name::.

for i = 1, 5 do
  for j = 1, 5 do
  -- goto only valid approach for nested break in Lua
    if i * j > 10 then
      goto done
    end
    io.write(i*j .. " ")
  end
end
::done::
print()
print("Stopped early")

Compromis entre while et repeat

while : utilisez-le lorsque zéro itération est possible : la condition est vérifiée en premier. repeat-until : utilisez-le lorsqu’au moins une itération est nécessaire : la vérification a lieu après. Préférez while pour la plupart des boucles. Utilisez repeat-until pour les menus, les demandes et les boucles de nouvelle tentative lorsque l’action doit avoir lieu avant la vérification.

-- while: may execute zero times
local ready = false
while ready do
  print("never prints")
end

-- repeat-until: always executes at least once
local done = false
repeat
  print("runs once even though done=false")
  done = true
until done

Vérification rapide

À quel moment la condition est-elle vérifiée dans une boucle repeat...until ?

Récapitulatif : while et repeat-until

Points essentiels :

while cond do ... end — vérifie avant ; peut ne jamais s’exécuter
repeat ... until cond — vérifie après ; s’exécute au moins une fois
break sort de la boucle la plus interne
goto ::label:: peut sortir de boucles imbriquées (Lua 5.2 ou version ultérieure)
Les variables locales de boucle sont recréées à chaque itération
Utilisez le modèle de l’accumulateur pour construire des résultats

Questions Fréquemment Posées

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

Oui — le texte complet de « Boucles while et repeat-until » 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 Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Boucles while et repeat-until » ?

Utilisez while et repeat-until pour effectuer des itérations guidées par des conditions. Tu pratiques Lua 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 Lua Academy ?

Aucune expérience préalable n'est requise. Lua 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-until » ?

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 Lua Academy ?

Oui. Chaque leçon Lua 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

← Retour à Lua Academy