Lua Academy · Leçon

Générateurs fondés sur les coroutines

Utilisez coroutine.wrap pour créer des séquences générées paresseusement.

Générateurs fondés sur les coroutines 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.

Pourquoi utiliser des générateurs avec coroutine

Les fermetures fonctionnent bien pour les générateurs simples. Mais si la logique de génération nécessite des boucles imbriquées ou un flux de contrôle complexe, un générateur avec coroutine est bien plus clair.

Principes de base de coroutine.wrap

coroutine.wrap(fn) renvoie une fonction. Chaque appel reprend la coroutine ; les valeurs produites via coroutine.yield deviennent la valeur de retour.

local gen = coroutine.wrap(function()
  coroutine.yield(1)
  coroutine.yield(2)
  coroutine.yield(3)
end)
for v in gen do print(v) end

Générateur de séquence infinie

Une coroutine peut produire des valeurs indéfiniment, ce qui la rend idéale pour les séquences infinies interrompues par l’appelant avec break.

local function naturals()
  return coroutine.wrap(function()
    local n = 0
    while true do
      n = n + 1
      coroutine.yield(n)
    end
  end)
end
for v in naturals() do
  if v > 5 then break end
  print(v)
end

Générateur de parcours d’arbre

Le parcours récursif en profondeur est trivial avec les coroutines : il suffit de produire des valeurs depuis les appels récursifs sans gérer explicitement une pile.

local function walkTree(node)
  return coroutine.wrap(function()
    local function recurse(n)
      coroutine.yield(n.value)
      for _, child in ipairs(n.children or {}) do
        recurse(child)
      end
    end
    recurse(node)
  end)
end

Générateur de Fibonacci

La suite de Fibonacci se prête naturellement à une coroutine : conservez deux variables d’état et produisez chaque terme.

local function fibs()
  return coroutine.wrap(function()
    local a, b = 0, 1
    while true do
      coroutine.yield(a)
      a, b = b, a + b
    end
  end)
end
local fib = fibs()
for i = 1, 8 do print(fib()) end

Transmettre des valeurs au générateur

L’argument transmis à la fonction reprise est la valeur de retour de yield, ce qui permet une communication bidirectionnelle.

local acc = coroutine.wrap(function()
  local total = 0
  while true do
    local n = coroutine.yield(total)
    total = total + (n or 0)
  end
end)
acc()  -- start
print(acc(10))  -- 10
print(acc(5))   -- 15

coroutine.wrap ou coroutine.create

wrap est plus simple et déclenche une erreur en cas de problème. create renvoie un objet thread et vous permet de gérer les erreurs à partir des valeurs de retour de resume.

Pipeline de générateurs

Chaînez des générateurs fondés sur des coroutines pour créer des pipelines différés : le producteur produit les données brutes, le filtre produit les éléments correspondants et la transformation produit les éléments transformés.

Propagation des erreurs

Si une coroutine encapsulée déclenche une erreur, la fonction d’encapsulation la déclenche également. Placez l’appel du générateur dans pcall pour une utilisation sûre.

Efficacité mémoire

Les générateurs avec coroutine sont différés : ils calculent les valeurs à la demande. Cela évite de construire de grandes tables intermédiaires, un avantage majeur pour les grands ensembles de données.

Gestion de l’épuisement

Lorsque la fonction de la coroutine renvoie une valeur (au lieu d’en produire), l’appel suivant de la fonction encapsulée renvoie nil, ce qui termine naturellement une boucle for générique.

Question sur les générateurs avec coroutine

Que se passe-t-il lorsque la fonction de coroutine d’un générateur fondé sur coroutine.wrap renvoie une valeur (au lieu d’en produire) ?

Récapitulatif : générateurs avec coroutine

coroutine.wrap transforme toute coroutine en fonction génératrice réutilisable. Elle permet de créer des séquences infinies différées, des parcours récursifs et des étapes de pipeline avec un flux de contrôle clair.

Questions Fréquemment Posées

La leçon « Générateurs fondés sur les coroutines » est-elle gratuite ?

Oui — le texte complet de « Générateurs fondés sur les coroutines » 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 « Générateurs fondés sur les coroutines » ?

Utilisez coroutine.wrap pour créer des séquences générées paresseusement. 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 « Générateurs fondés sur les coroutines » ?

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