0Pricing
Lua Academy · Lezione

Iteratori con stato tramite closure

Costruisca iteratori che mantengano lo stato tra le chiamate usando le closure.

Iteratori con stato tramite closure è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Quando le closure sono utili

Quando un iteratore deve mantenere uno stato complesso e in evoluzione (posizione, stack, cronologia), le closure sono lo strumento naturale. Lo stato vive negli upvalue.

Pattern dell’iteratore con closure

Restituisca una singola funzione; lo stato viene mantenuto negli upvalue. Il generic for non fornisce alcuno stato esterno: chiama semplicemente la funzione a ogni iterazione.

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

Iteratore delle righe di un file

Un iteratore classico basato su una closure con stato restituisce le righe di un file handle fino a 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

Iteratore filtrante

Avvolga un iteratore esistente con una closure che salta gli elementi che non soddisfano un predicato.

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

Iteratore con mapping

Un iteratore con mapping trasforma ogni elemento al volo senza creare una tabella intermedia.

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

Iteratore zip

Un iteratore zip legge contemporaneamente da due iteratori e si arresta quando uno dei due è esaurito.

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

Iteratore concatenato

Un iteratore concatenato esaurisce un iteratore prima di passare a quello successivo.

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

Iteratore limitato

Limiti un iteratore a un massimo di N valori usando un contatore nella closure.

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

Iteratore per la visita di un albero

Una visita in profondità di un albero usa uno stack (una tabella come upvalue) per mantenere lo stato della visita.

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

Considerazioni sulla memoria

Gli iteratori con stato allocano un oggetto closure. Nei cicli interni estremamente intensivi, può essere preferibile un iteratore senza stato. Per le visite complesse, la closure vale ampiamente il costo.

Confronto: con stato e senza stato

  • Con stato: stato complesso, qualsiasi ordine di visita, facile da scrivere.
  • Senza stato: accesso sequenziale semplice, nessuna allocazione, veloce.

Domanda sugli iteratori con stato

Dove memorizza il proprio stato un iteratore basato su una closure con stato?

Riepilogo: iteratori con stato

Gli iteratori con stato basati su closure memorizzano lo stato complesso della visita negli upvalue, consentendo filtri, mapping, alberi e pipeline lazy, tutti componibili e efficienti in termini di memoria.

Domande Frequenti

La lezione «Iteratori con stato tramite closure» è gratuita?

Sì — il testo completo di «Iteratori con stato tramite closure» è 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 «Iteratori con stato tramite closure»?

Costruisca iteratori che mantengano lo stato tra le chiamate usando le closure. 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 3 di 4.

Quanto tempo richiede la lezione «Iteratori con stato tramite closure»?

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

  1. Il protocollo for generico
  2. Iteratori senza stato
  3. Iteratori con stato tramite closure
  4. Generatori basati su coroutine
← Torna a Lua Academy