Lua Academy · Lezione

Generatori basati su coroutine

Utilizzi coroutine.wrap per creare sequenze di generatori lazy.

Generatori basati su coroutine è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Motivazione per i generatori coroutine

Le closure funzionano bene per i generatori semplici. Tuttavia, se la logica di generazione richiede cicli annidati o un flusso di controllo complesso, un generatore coroutine è molto più chiaro.

Nozioni di base su coroutine.wrap

coroutine.wrap(fn) restituisce una funzione. Ogni chiamata riprende la coroutine; i valori restituiti tramite coroutine.yield diventano il valore restituito.

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

Generatore di sequenze infinite

Una coroutine può restituire valori indefinitamente, il che la rende ideale per sequenze infinite terminate dal chiamante con 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

Generatore per la visita di un albero

La visita ricorsiva in profondità è semplice con le coroutine: basta restituire valori dalle chiamate ricorsive senza gestire uno stack esplicito.

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

Generatore di Fibonacci

La sequenza di Fibonacci si presta naturalmente a una coroutine: mantenga due variabili di stato e restituisca ogni termine.

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

Passaggio di valori al generatore

L'argomento passato alla funzione ripresa è il valore restituito da yield, consentendo una comunicazione bidirezionale.

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 e coroutine.create a confronto

wrap è più semplice e genera un errore in caso di errore. create restituisce un oggetto thread e consente di gestire gli errori tramite i valori restituiti da resume.

Pipeline di generatori

Concateni generatori basati su coroutine per creare pipeline lazy: il produttore restituisce dati grezzi, il filtro restituisce gli elementi corrispondenti e il mapping restituisce gli elementi trasformati.

Propagazione degli errori

Se una coroutine avvolta genera un errore, anche la funzione wrap genera un errore. Avvolga la chiamata al generatore in pcall per un consumo sicuro.

Efficienza della memoria

I generatori coroutine sono lazy: calcolano i valori su richiesta. In questo modo evitano di creare grandi tabelle intermedie, un vantaggio importante con dataset di grandi dimensioni.

Gestione dell'esaurimento

Quando la funzione della coroutine termina (invece di restituire un valore), la chiamata successiva alla funzione avvolta restituisce nil, terminando naturalmente un ciclo for generico.

Domanda sui generatori coroutine

Cosa accade quando la funzione della coroutine di un generatore basato su coroutine.wrap termina (invece di restituire un valore)?

Riepilogo: generatori coroutine

coroutine.wrap trasforma qualsiasi coroutine in una funzione generatrice riutilizzabile. Consente di creare sequenze infinite lazy, visite ricorsive e fasi di pipeline con un flusso di controllo chiaro.

Domande Frequenti

La lezione «Generatori basati su coroutine» è gratuita?

Sì — il testo completo di «Generatori basati su coroutine» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Generatori basati su coroutine»?

Utilizzi coroutine.wrap per creare sequenze di generatori lazy. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Generatori basati su coroutine»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Lua Academy