Lua Academy · Lektion

Korutinbaserade generatorer

Använd coroutine.wrap för att skapa lata generatorsekvenser.

Lektion 4 av 413 steg

Korutinbaserade generatorer är en gratis lektion i Lua Academy på CoddyKit. Detta är lektion 4 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.

Motivering för coroutine-generatorer

Closures fungerar bra för enkla generatorer. Men om genereringslogiken kräver nästlade loopar eller ett komplext kontrollflöde blir en coroutine-generator mycket renare.

Grunderna i coroutine.wrap

coroutine.wrap(fn) returnerar en funktion. Varje anrop återupptar coroutinen; värden som avges via coroutine.yield blir returvärdet.

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

Generator för oändliga sekvenser

En coroutine kan avge värden utan slut, vilket gör den perfekt för oändliga sekvenser som avslutas av anroparen med 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

Generator för trädgenomgång

Rekursiv djupgenomgång är enkel med coroutines — avge bara värden från rekursiva anrop utan att hantera en explicit stack.

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

Fibonacci-generator

Fibonacci-sekvensen lämpar sig naturligt som en coroutine: behåll två tillståndsvariabler och avge varje term.

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

Skicka värden till generatorn

Argumentet till den återupptagna funktionen blir returvärdet från yield, vilket möjliggör kommunikation i båda riktningarna.

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 kontra coroutine.create

wrap är enklare och kastar ett fel. create returnerar ett trådobjekt och låter dig hantera fel från returvärdena i resume.

Generatorpipeline

Kedja coroutine-baserade generatorer till lata pipelines: producenten avger rådata, filtret avger matchande element och mappningen avger transformerade element.

Felpropagering

Om en omsluten coroutine kastar ett fel kastar även wrap-funktionen ett fel. Omslut generatoranropet i pcall för säker användning.

Minneseffektivitet

Coroutine-generatorer är lata — de beräknar värden vid behov. Det undviker att stora mellanliggande tabeller byggs upp, vilket är en stor fördel för stora datamängder.

Hantering när generatorn är uttömd

När coroutine-funktionen returnerar (i stället för att avge ett värde) returnerar nästa anrop av den omslutna funktionen nil, vilket naturligt avslutar en generell for-loop.

Fråga om coroutine-generatorer

Vad händer när coroutine-funktionen i en generator baserad på coroutine.wrap returnerar (i stället för att avge ett värde)?

Besvara frågan i den interaktiva lektionen

Sammanfattning: coroutine-generatorer

coroutine.wrap omvandlar valfri coroutine till en återanvändbar generatorfunktion. Den möjliggör lata oändliga sekvenser, rekursiva genomgångar och pipelinesteg med ett rent kontrollflöde.

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 ”Korutinbaserade generatorer” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lua Academy, inklusive ”Korutinbaserade generatorer”, 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 ”Korutinbaserade generatorer”?

Använd coroutine.wrap för att skapa lata generatorsekvenser. 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 4 av 4.

Hur lång tid tar lektionen ”Korutinbaserade generatorer”?

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