Lua Academy · Lektion

Tillståndsbevarande iteratorer med closures

Bygg iteratorer som bevarar tillstånd mellan anrop med hjälp av closures.

Lektion 3 av 413 steg

Tillståndsbevarande iteratorer med closures är en gratis lektion i Lua Academy på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lua Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lua Academy innehåller totalt 4 lektioner.

När closures är användbara

När en iterator behöver underhålla komplext tillstånd som förändras över tid (position, stack eller historik) är closures det naturliga verktyget. Tillståndet finns i upvalues.

Mönster för closure-iterator

Returnera en enda funktion; tillståndet lagras i upvalues. Den generiska for-loopen tillhandahåller inget externt tillstånd – den anropar bara funktionen varje gång.

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

Iterator för fillinjer

En klassisk tillståndsbevarande closure-iterator ger rader från ett filhandtag tills EOF nås.

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

Filtrerande iterator

Omslut en befintlig iterator med en closure som hoppar över element som inte matchar ett predikat.

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

Mappande iterator

En mappningsiterator transformerar varje element direkt, utan att skapa en mellanliggande tabell.

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

Zip-iterator

En zip-iterator hämtar värden från två iteratorer samtidigt och slutar när någon av dem är uttömd.

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

Kedjad iterator

En kedjeiterator tömmer en iterator innan den byter till nästa.

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

Begränsad iterator

Begränsa en iterator till högst N värden med hjälp av en räknare i en closure.

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

Iterator för trädgenomgång

En djupet-först-genomgång av ett träd använder en stack (en tabell som upvalue) för att bevara genomgångens tillstånd.

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

Minnesöverväganden

Tillståndsbevarande iteratorer allokerar ett closure-objekt. För extremt täta inre loopar kan en tillståndslös iterator vara att föredra. För komplexa genomgångar är closure-objektet väl värt kostnaden.

Jämförelse: tillståndsbevarande kontra tillståndslös

Tillståndsbevarande: komplext tillstånd, valfri genomgångsordning, enkelt att skriva.
Tillståndslös: enkel sekventiell åtkomst, ingen allokering, snabb.

Fråga om tillståndsbevarande iteratorer

Var lagrar en tillståndsbevarande closure-iterator sitt tillstånd?

Besvara frågan i den interaktiva lektionen

Sammanfattning: tillståndsbevarande iteratorer

Closure-baserade tillståndsbevarande iteratorer lagrar komplext genomgångstillstånd i upvalues, vilket möjliggör filter, mappningar, träd och lata pipelines — allt komponerbart och minneseffektivt.

Gratis att börja

Lär dig Lua med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 40
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Tillståndsbevarande iteratorer med closures” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lua Academy, inklusive ”Tillståndsbevarande iteratorer med closures”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lua Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Tillståndsbevarande iteratorer med closures”?

Bygg iteratorer som bevarar tillstånd mellan anrop med hjälp av closures. Ni övar på Lua Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lua Academy?

Du behöver inga förkunskaper. Utbildningen i Lua Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Tillståndsbevarande iteratorer med closures”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lua Academy-lektionen?

Ja. Varje Lua Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Protokollet för generisk for
Tillståndslösa iteratorer
Tillståndsbevarande iteratorer med closures
Korutinbaserade generatorer

← Tillbaka till Lua Academy