Lua Academy · Les

Generators op basis van coroutines

Gebruik coroutine.wrap om lazy generatorreeksen te maken

Les 4 van 413 stappen

Generators op basis van coroutines is een gratis Lua Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Waarom coroutine-generatoren?

Closures werken goed voor eenvoudige generatoren. Maar als de generatielogica geneste lussen of een complexe besturingsstroom vereist, is een coroutine-generator veel overzichtelijker.

Basisprincipes van coroutine.wrap

coroutine.wrap(fn) retourneert een functie. Elke aanroep hervat de coroutine; waarden die via coroutine.yield worden opgeleverd, worden de retourwaarde.

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

Generator voor oneindige reeksen

Een coroutine kan onbeperkt waarden opleveren en is daardoor ideaal voor oneindige reeksen die door de aanroeper met break worden beëindigd.

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 voor boomdoorloop

Een recursieve diepe doorloop is eenvoudig met coroutines: lever gewoon waarden op vanuit recursieve aanroepen zonder zelf een expliciete stack te beheren.

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

De Fibonacci-reeks past van nature bij een coroutine: houd twee statusvariabelen bij en lever elke term op.

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

Waarden aan de generator doorgeven

Het argument van de hervatte functie is de retourwaarde van yield, waardoor communicatie in twee richtingen mogelijk is.

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

wrap is eenvoudiger en genereert een fout. create retourneert een thread-object en laat je fouten afhandelen via de retourwaarden van resume.

Generatorpijplijn

Koppel generatoren op basis van coroutines voor luie verwerkingspijplijnen: de producent levert onbewerkte gegevens op, het filter levert overeenkomende items op en de mapping levert getransformeerde items op.

Foutdoorgifte

Als een ingepakte coroutine een fout genereert, genereert de wrap-functie die ook. Plaats de aanroep van de generator in pcall voor veilige verwerking.

Geheugenefficiëntie

Coroutine-generatoren zijn lui: ze berekenen waarden wanneer daarom wordt gevraagd. Zo voorkom je dat grote tussentijdse tabellen worden opgebouwd, wat een groot voordeel is bij grote gegevensverzamelingen.

Afhandeling van uitputting

Wanneer de coroutine-functie retourneert (en geen waarden oplevert), retourneert de volgende aanroep van de ingepakte functie nil, waardoor een generieke for-lus vanzelf eindigt.

Vraag over coroutine-generatoren

Wat gebeurt er wanneer de coroutine-functie van een generator op basis van coroutine.wrap retourneert (en geen waarden oplevert)?

Beantwoord dit in de interactieve les

Samenvatting: coroutine-generatoren

coroutine.wrap maakt van elke coroutine een herbruikbare generatorfunctie. Hiermee kun je luie oneindige reeksen, recursieve doorlopen en pijplijnfasen met een overzichtelijke besturingsstroom maken.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Generators op basis van coroutines” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Generators op basis van coroutines”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “Generators op basis van coroutines”?

Gebruik coroutine.wrap om lazy generatorreeksen te maken Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Generators op basis van coroutines”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Lua Academy