Lua Academy · Lektion

Coroutine-baserede generatorer

Brug coroutine.wrap til at oprette lazy generatorsekvenser.

Lektion 4 af 413 trin

Coroutine-baserede generatorer er en gratis Lua Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lua Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lua Academy-kurset indeholder 4 lektioner i alt.

Motivation for coroutine-generatorer

Closures fungerer godt til simple generatorer. Men hvis genereringslogikken kræver indlejrede løkker eller kompleks kontrolflow, er en coroutine-generator langt mere overskuelig.

Grundlæggende om coroutine.wrap

coroutine.wrap(fn) returnerer en funktion. Hvert kald genoptager coroutinen; værdier, der leveres via coroutine.yield, bliver returværdien.

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

Generator til uendelige sekvenser

En coroutine kan levere værdier uendeligt, hvilket gør den perfekt til uendelige sekvenser, som afsluttes af kalderen 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 til træ-gennemgang

Rekursiv dybdegående gennemgang er enkel med coroutiner — du skal blot levere værdier fra rekursive kald uden at administrere en eksplicit stak.

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 sig naturligt til en coroutine: Bevar to tilstandsvariabler, og lever hvert led.

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

Videregivelse af værdier til generatoren

Argumentet til den genoptagne funktion er returværdien fra yield, hvilket muliggør kommunikation 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 ved fejl. create returnerer et trådobjekt og lader dig håndtere fejl fra returværdierne fra resume.

Generatorpipeline

Kæd coroutine-baserede generatorer til lazy pipelines: producenten leverer rådata, filteret leverer matchende elementer, og mapperen leverer transformerede elementer.

Fejlvideregivelse

Hvis en indpakket coroutine kaster en fejl, kaster wrap-funktionen også en fejl. Pak generator-kaldet ind i pcall for sikker behandling.

Hukommelseseffektivitet

Coroutine-generatorer er lazy — de beregner værdier efter behov. Det undgår at opbygge store mellemliggende tabeller, hvilket er en væsentlig fordel ved store datasæt.

Håndtering af udtømning

Når coroutine-funktionen returnerer (i stedet for at levere en værdi), returnerer det næste kald til den indpakkede funktion nil, så en generisk for-løkke afsluttes naturligt.

Spørgsmål om coroutine-generatorer

Hvad sker der, når coroutine-funktionen i en generator baseret på coroutine.wrap returnerer (i stedet for at levere en værdi)?

Besvar den i den interaktive lektion

Opsummering: coroutine-generatorer

coroutine.wrap omdanner enhver coroutine til en genanvendelig generatorfunktion. Den muliggør lazy uendelige sekvenser, rekursive gennemgange og pipeline-trin med et overskueligt kontrolflow.

Gratis at komme i gang

Lær Lua med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 40
Lektioner: 159

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Coroutine-baserede generatorer” gratis?

Ja — alle 3 lektioner i læringssporet Lua Academy, inklusive “Coroutine-baserede generatorer”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lua Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Coroutine-baserede generatorer”?

Brug coroutine.wrap til at oprette lazy generatorsekvenser. Du øver dig i Lua Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lua Academy?

Der kræves ingen tidligere erfaring. Lua Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Coroutine-baserede generatorer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lua Academy-lektion?

Ja. Alle Lua Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Protokollen for generisk for
Tilstandsløse iteratorer
Tilstandsbaserede iteratorer med closures
Coroutine-baserede generatorer

← Tilbage til Lua Academy