Lua Academy · leksjon

Coroutine-baserte generatorer

Bruk coroutine.wrap til å opprette late generatorsekvenser.

Leksjon 4 av 413 trinn

Coroutine-baserte generatorer er en gratis leksjon i Lua Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lua Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lua Academy inneholder totalt 4 leksjoner.

Hvorfor bruke coroutine-generatorer

Lukninger fungerer godt for enkle generatorer. Men hvis genereringslogikken krever nøstede løkker eller kompleks kontrollflyt, er en coroutine-generator mye ryddigere.

Grunnleggende om coroutine.wrap

coroutine.wrap(fn) returnerer en funksjon. Hvert kall gjenopptar coroutine-en, og verdier som leveres via coroutine.yield, blir returverdien.

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

Generator for uendelige sekvenser

En coroutine kan levere verdier uten ende, noe som gjør den perfekt for uendelige sekvenser som avsluttes av kalleren 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 for tretraversering

Rekursiv dybde-traversering er trivielt med coroutines – bare lever verdier fra rekursive kall uten å administrere en eksplisitt stakk.

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 egner seg naturlig som en coroutine: behold to tilstandsvariabler og lever hvert ledd.

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

Sende verdier inn i generatoren

Argumentet til den gjenopptatte funksjonen er returverdien fra yield, noe som muliggjør kommunikasjon i begge retninger.

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 er enklere og kaster feil. create returnerer et trådobjekt og lar deg håndtere feil fra returverdiene til resume.

Generatorpipeline

Kjed coroutine-baserte generatorer for late pipelines: produsenten leverer rådata, filteret leverer samsvarende elementer, og map-funksjonen leverer transformerte elementer.

Feilvideresending

Hvis en innpakket coroutine kaster en feil, kaster også wrap-funksjonen en feil. Pakk generatorkallet inn i pcall for trygg konsumering.

Minneeffektivitet

Coroutine-generatorer er late – de beregner verdier ved behov. Dermed unngår de å bygge store mellomliggende tabeller, noe som er en stor fordel for store datasett.

Håndtering av uttømming

Når coroutine-funksjonen returnerer (i stedet for å levere en verdi), returnerer neste kall til den innpakkede funksjonen nil, slik at en generisk for-løkke avsluttes naturlig.

Spørsmål om coroutine-generatorer

Hva skjer når coroutine-funksjonen til en generator basert på coroutine.wrap returnerer (i stedet for å levere en verdi)?

Besvar den i den interaktive leksjonen

Oppsummering: coroutine-generatorer

coroutine.wrap gjør enhver coroutine om til en gjenbrukbar generatorfunksjon. Den muliggjør late, uendelige sekvenser, rekursive traverseringer og pipelinetrinn med ryddig kontrollflyt.

Gratis å komme i gang

Lær deg Lua med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 40
Leksjoner: 159

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Coroutine-baserte generatorer» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lua Academy, inkludert «Coroutine-baserte generatorer», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lua Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Coroutine-baserte generatorer»?

Bruk coroutine.wrap til å opprette late generatorsekvenser. Du øver på Lua Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Lua Academy?

Ingen tidligere erfaring er nødvendig. Lua Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Coroutine-baserte generatorer»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Lua Academy-leksjonen?

Ja. Alle Lua Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Lua Academy