0Pricing
Lua Academy · Lektion

Generatoren auf Coroutine-Basis

Verwenden Sie coroutine.wrap, um verzögert erzeugte Sequenzen zu erstellen

Generatoren auf Coroutine-Basis ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Motivation für Coroutine-Generatoren

Closures eignen sich gut für einfache Generatoren. Wenn die Generierungslogik jedoch verschachtelte Schleifen oder komplexe Kontrollflüsse erfordert, ist ein Coroutine-Generator deutlich übersichtlicher.

Grundlagen von coroutine.wrap

coroutine.wrap(fn) gibt eine Funktion zurück. Jeder Aufruf setzt die Coroutine fort; über coroutine.yield gelieferte Werte werden zum Rückgabewert.

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 unendliche Sequenzen

Eine Coroutine kann unbegrenzt Werte liefern und eignet sich daher ideal für unendliche Sequenzen, die der Aufrufer mit break beendet.

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 Baumtraversierungen

Eine rekursive Tiefentraversierung ist mit Coroutines unkompliziert: Liefern Sie einfach Werte aus rekursiven Aufrufen, ohne einen expliziten Stack zu verwalten.

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

Die Fibonacci-Folge eignet sich hervorragend als Coroutine: Halten Sie zwei Zustandsvariablen vor und liefern Sie jeden Folgenterm.

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

Werte an den Generator übergeben

Das Argument der fortgesetzten Funktion ist der Rückgabewert von yield und ermöglicht so eine Kommunikation in beide Richtungen.

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 im Vergleich zu coroutine.create

wrap ist einfacher und löst bei Fehlern eine Ausnahme aus. create gibt ein Thread-Objekt zurück und ermöglicht es Ihnen, Fehler anhand der Rückgabewerte von resume zu behandeln.

Generator-Pipeline

Verketten Sie Coroutine-basierte Generatoren zu verzögerten Pipelines: Der Producer liefert Rohdaten, der Filter passende Elemente und das Mapping transformierte Elemente.

Fehlerweitergabe

Wenn eine umschlossene Coroutine einen Fehler auslöst, löst auch die Wrap-Funktion einen Fehler aus. Umschließen Sie den Generatoraufruf mit pcall, um ihn sicher zu verwenden.

Speichereffizienz

Coroutine-Generatoren arbeiten verzögert: Sie berechnen Werte erst bei Bedarf. Dadurch entfällt das Erstellen großer temporärer Tabellen – ein wesentlicher Vorteil bei großen Datensätzen.

Umgang mit der Erschöpfung

Wenn die Coroutine-Funktion zurückkehrt (statt Werte zu liefern), gibt der nächste Aufruf der umschlossenen Funktion nil zurück und beendet so eine generische for-Schleife auf natürliche Weise.

Frage zu Coroutine-Generatoren

Was geschieht, wenn die Coroutine-Funktion eines auf coroutine.wrap basierenden Generators zurückkehrt (statt Werte zu liefern)?

Zusammenfassung: Coroutine-Generatoren

coroutine.wrap verwandelt jede Coroutine in eine wiederverwendbare Generatorfunktion. Damit lassen sich verzögerte unendliche Sequenzen, rekursive Traversierungen und Pipeline-Stufen mit übersichtlichem Kontrollfluss umsetzen.

Häufig gestellte Fragen

Ist die Lektion „Generatoren auf Coroutine-Basis“ kostenlos?

Ja — der vollständige Text von „Generatoren auf Coroutine-Basis“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Generatoren auf Coroutine-Basis“?

Verwenden Sie coroutine.wrap, um verzögert erzeugte Sequenzen zu erstellen Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Generatoren auf Coroutine-Basis“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Das Protokoll für generische for-Schleifen
  2. Zustandslose Iteratoren
  3. Zustandsbehaftete Iteratoren mit Closures
  4. Generatoren auf Coroutine-Basis
← Zurück zu Lua Academy