Lua Academy · Leçon

Itérateurs avec état et fermetures

Construisez des itérateurs qui conservent leur état entre les appels grâce aux fermetures.

Itérateurs avec état et fermetures est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Quand les fermetures sont utiles

Lorsqu’un itérateur doit conserver un état complexe et évolutif (position, pile, historique), les fermetures sont l’outil naturel. L’état vit dans les variables capturées.

Modèle d’itérateur avec fermeture

Renvoyez une seule fonction ; l’état est conservé dans les variables capturées. Le for générique ne fournit aucun état externe : il appelle simplement la fonction à chaque fois.

local function chars(s)
  local i = 0
  return function()
    i = i + 1
    local c = s:sub(i, i)
    return c ~= "" and c or nil
  end
end
for c in chars("lua") do print(c) end

Itérateur de lignes d’un fichier

Un itérateur classique à fermeture avec état renvoie les lignes d’un descripteur de fichier jusqu’à EOF.

local function lines(filename)
  local f = io.open(filename, "r")
  return function()
    local line = f:read("*l")
    if not line then f:close() end
    return line
  end
end

Itérateur filtrant

Enveloppez un itérateur existant dans une fermeture qui ignore les éléments ne correspondant pas à un prédicat.

local function filtered(iter, pred)
  return function()
    local v = iter()
    while v ~= nil and not pred(v) do
      v = iter()
    end
    return v
  end
end

Itérateur avec transformation

Un itérateur avec transformation transforme chaque élément à la volée sans construire de table intermédiaire.

local function mapped(iter, fn)
  return function()
    local v = iter()
    if v ~= nil then return fn(v) end
  end
end

Itérateur combiné

Un itérateur de combinaison lit simultanément deux itérateurs et s’arrête dès que l’un d’eux est épuisé.

local function zipped(iter1, iter2)
  return function()
    local a, b = iter1(), iter2()
    if a ~= nil and b ~= nil then return a, b end
  end
end

Itérateur chaîné

Un itérateur chaîné épuise un itérateur avant de passer au suivant.

local function chained(...)
  local iters = {...}
  local idx = 1
  return function()
    while idx <= #iters do
      local v = iters[idx]()
      if v ~= nil then return v end
      idx = idx + 1
    end
  end
end

Itérateur limité

Limitez un itérateur à N valeurs au maximum à l’aide d’un compteur dans une fermeture.

local function take(n, iter)
  local count = 0
  return function()
    count = count + 1
    if count <= n then return iter() end
  end
end

Itérateur de parcours d’arbre

Un parcours d’arbre en profondeur utilise une pile (une table comme valeur ascendante) pour conserver l’état du parcours.

local function dfs(root)
  local stack = {root}
  return function()
    if #stack == 0 then return nil end
    local node = table.remove(stack)
    for _, child in ipairs(node.children or {}) do
      stack[#stack+1] = child
    end
    return node
  end
end

Considérations relatives à la mémoire

Les itérateurs avec état allouent un objet fermeture. Pour des boucles internes extrêmement serrées, un itérateur sans état peut être préférable. Pour les parcours complexes, la fermeture en vaut largement la peine.

Comparaison : avec état ou sans état

Avec état : état complexe, n’importe quel ordre de parcours, facile à écrire.
Sans état : accès séquentiel simple, aucune allocation, rapide.

Question sur les itérateurs avec état

Où un itérateur à fermeture avec état stocke-t-il son état ?

Récapitulatif : itérateurs avec état

Les itérateurs avec état fondés sur des fermetures stockent l’état complexe du parcours dans des valeurs ascendantes, ce qui permet les filtres, les transformations, les arbres et les pipelines différés — tous composables et économes en mémoire.

Questions Fréquemment Posées

La leçon « Itérateurs avec état et fermetures » est-elle gratuite ?

Oui — le texte complet de « Itérateurs avec état et fermetures » 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 « Itérateurs avec état et fermetures » ?

Construisez des itérateurs qui conservent leur état entre les appels grâce aux fermetures. 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 3 sur 4.

Combien de temps prend la leçon « Itérateurs avec état et fermetures » ?

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