Lua Academy · Leçon

for générique et break

Utilisez for générique avec pairs/ipairs et contrôlez le déroulement des boucles avec break.

for générique et break est une leçon Lua 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 Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Protocole du for générique

La boucle for générique de Lua fonctionne avec une fonction itératrice. Sa syntaxe est for vars in iter_func, state, init do. À chaque itération, Lua appelle iter_func(state, lastVar) et affecte les valeurs retournées à vars. La boucle s’arrête lorsque la première valeur retournée est nil.

-- Manual use of next() iterator
local t = {a=1, b=2, c=3}
local key, val = next(t, nil)   -- first entry
while key ~= nil do
  print(key, val)
  key, val = next(t, key)       -- advance
end

pairs() pour toutes les clés

pairs(t) renvoie un itérateur qui parcourt toutes les paires clé-valeur d’une table, y compris les clés texte, les clés entières et les tables mixtes. L’ordre de parcours des clés non entières n’est pas défini (ordre de hachage). La partie tableau et la partie associative sont toutes deux incluses.

local config = {
  host = "localhost",
  port = 8080,
  debug = true,
  [1] = "first",
}

for key, value in pairs(config) do
  print(key, value)
end
-- Prints all 4 entries in any order

ipairs() pour les clés de tableau

ipairs(t) parcourt les clés entières à partir de 1 et s’arrête à la première valeur nil. Son comportement est sûr, prévisible et conserve l’ordre. Utilisez ipairs pour les tables assimilables à des tableaux lorsque l’ordre est important et que vous souhaitez vous arrêter au premier trou.

local fruits = {"apple", "banana", "cherry"}

for i, fruit in ipairs(fruits) do
  print(i, fruit)
end
-- 1  apple
-- 2  banana
-- 3  cherry

-- stops at first nil
local t = {10, 20, nil, 40}
for i, v in ipairs(t) do
  print(i, v)  -- only 1,10 and 2,20
end

pairs ou ipairs

Sachez choisir : ipairs s’utilise pour les tableaux séquentiels ordonnés ; pairs pour les dictionnaires ou les tables mixtes. ipairs s’arrête au premier trou contenant nil ; pairs parcourt toutes les clés non nil. Pour les tableaux purs, ipairs est plus idiomatique.

local mixed = {10, 20, key="val", 30}

-- ipairs only sees array part in order
print("ipairs:")
for i, v in ipairs(mixed) do
  print(i, v)  -- 1:10, 2:20, 3:30
end

-- pairs sees everything
print("pairs:")
for k, v in pairs(mixed) do
  print(k, v)  -- 1:10, 2:20, 3:30, key:val
end

Itérateur personnalisé avec une fermeture

Vous pouvez écrire votre propre itérateur sous forme de fermeture. La fonction génératrice renvoie une fermeture avec état qui avance la position à chaque appel. Lorsqu’il ne reste plus rien à renvoyer, elle renvoie nil pour arrêter le for générique.

local function range(from, to, step)
  step = step or 1
  local i = from - step
  return function()
    i = i + step
    if i <= to then return i end
  end
end

for n in range(1, 10, 2) do
  io.write(n .. " ")
end
print()  -- 1 3 5 7 9

string.gmatch comme itérateur

string.gmatch(s, pattern) renvoie un itérateur sur toutes les correspondances du modèle dans la chaîne s. Il est couramment utilisé pour découper des chaînes, extraire des jetons ou trouver toutes les occurrences d’un modèle.

local sentence = "the quick brown fox"

for word in string.gmatch(sentence, "%a+") do
  print(word)
end
-- the
-- quick
-- brown
-- fox

break dans un for générique

Vous pouvez quitter prématurément une boucle for générique avec break. Cela est utile pour effectuer une recherche : parcourez les éléments jusqu’à trouver une correspondance, puis utilisez break. Après la sortie, l’exécution continue à l’instruction située après end.

local inventory = {
  {name="sword", damage=50},
  {name="shield", armor=30},
  {name="bow", damage=35},
}

local target = "shield"
for i, item in ipairs(inventory) do
  if item.name == target then
    print("Found at index", i)
    break
  end
end

Modifier des tables pendant un parcours

N’insérez jamais de clés dans une table et n’en supprimez jamais pendant un parcours avec pairs() : le comportement n’est pas défini (certaines modifications peuvent être détectées et d’autres ignorées). Si vous devez modifier une table, rassemblez les changements dans une liste temporaire et appliquez-les après la boucle.

local t = {a=1, b=2, c=3, d=4}
local toDelete = {}

-- Collect keys to delete
for k, v in pairs(t) do
  if v % 2 == 0 then
    toDelete[#toDelete+1] = k
  end
end

-- Delete after iteration
for _, k in ipairs(toDelete) do
  t[k] = nil
end
-- t = {a=1, c=3}

Modèle d’énumération

Lorsque vous avez besoin à la fois de l’indice et de la valeur, utilisez ipairs, qui fournit les deux. Lorsque seules les valeurs vous intéressent et que l’indice vous est inutile, vous pouvez utiliser _ comme nom de variable conventionnel indiquant que l’indice n’est pas utilisé.

local colors = {"red", "green", "blue"}

-- With index
for i, color in ipairs(colors) do
  print(i .. ": " .. color)
end

-- Ignore index with _
for _, color in ipairs(colors) do
  print(color)  -- just the values
end

Utiliser next() directement

next(t, key) est la fonction de parcours sous-jacente. Elle renvoie la paire clé-valeur qui suit key, ou nil s’il n’y en a plus. next(t, nil) renvoie la première entrée. Vous pouvez utiliser next(t) ~= nil pour vérifier qu’une table n’est pas vide, ce qui est plus rapide que de compter.

local function isEmpty(t)
  return next(t) == nil
end

print(isEmpty({}))       -- true
print(isEmpty({1,2,3}))  -- false
print(isEmpty({a=1}))    -- false

Vérification rapide

Quel itérateur s’arrête au premier trou contenant nil dans une table ?

Récapitulatif : for générique et break

Résumé :

pairs(t) — toutes les clés, dans un ordre quelconque
ipairs(t) — clés entières de 1 à n, dans l’ordre, arrêt à nil
Itérateurs personnalisés : renvoyez une fermeture qui renvoie nil pour s’arrêter
break quitte prématurément la boucle
Ne modifiez jamais une table pendant un parcours avec pairs ; rassemblez les changements et appliquez-les ensuite
next(t) == nil — vérification rapide d’une table vide

Questions Fréquemment Posées

La leçon « for générique et break » est-elle gratuite ?

Oui — le texte complet de « for générique et break » 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 « for générique et break » ?

Utilisez for générique avec pairs/ipairs et contrôlez le déroulement des boucles avec break. 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 4 sur 4.

Combien de temps prend la leçon « for générique et break » ?

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