0Pricing
Lua Academy · Lektion

Zustandsbehaftete Iteratoren mit Closures

Erstellen Sie Iteratoren, die mit Closures ihren Zustand zwischen Aufrufen bewahren

Zustandsbehaftete Iteratoren mit Closures ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Wann Closures hilfreich sind

Wenn ein Iterator einen komplexen, sich verändernden Zustand (Position, Stack, Verlauf) verwalten muss, sind Closures das natürliche Werkzeug. Der Zustand wird in Upvalues gespeichert.

Muster für Closure-Iteratoren

Geben Sie eine einzelne Funktion zurück; der Zustand wird in Upvalues gespeichert. Generic for stellt keinen externen Zustand bereit, sondern ruft die Funktion lediglich bei jeder Iteration auf.

local function chars(s)
  local i = 0
  return function()
    i = i + 1
    local c = s:sub(i, i)
    return c ~= "" and c or nil
  end
end
for c in chars("lua") do print(c) end

Dateizeilen-Iterator

Ein klassischer zustandsbehafteter Closure-Iterator liefert Zeilen aus einem Datei-Handle, bis EOF erreicht ist.

local function lines(filename)
  local f = io.open(filename, "r")
  return function()
    local line = f:read("*l")
    if not line then f:close() end
    return line
  end
end

Filternder Iterator

Umschließen Sie einen vorhandenen Iterator mit einer Closure, die Elemente überspringt, die ein Prädikat nicht erfüllen.

local function filtered(iter, pred)
  return function()
    local v = iter()
    while v ~= nil and not pred(v) do
      v = iter()
    end
    return v
  end
end

Abbildender Iterator

Ein Mapping-Iterator transformiert jedes Element während der Iteration, ohne eine temporäre Tabelle zu erstellen.

local function mapped(iter, fn)
  return function()
    local v = iter()
    if v ~= nil then return fn(v) end
  end
end

Gekoppelter Iterator

Ein Zip-Iterator liest gleichzeitig aus zwei Iteratoren und stoppt, sobald einer von beiden erschöpft ist.

local function zipped(iter1, iter2)
  return function()
    local a, b = iter1(), iter2()
    if a ~= nil and b ~= nil then return a, b end
  end
end

Verketteter Iterator

Ein Ketten-Iterator erschöpft zunächst einen Iterator, bevor er zum nächsten wechselt.

local function chained(...)
  local iters = {...}
  local idx = 1
  return function()
    while idx <= #iters do
      local v = iters[idx]()
      if v ~= nil then return v end
      idx = idx + 1
    end
  end
end

Gezählter Iterator

Begrenzen Sie einen Iterator mithilfe eines Closure-Zählers auf höchstens N Werte.

local function take(n, iter)
  local count = 0
  return function()
    count = count + 1
    if count <= n then return iter() end
  end
end

Iterator für Baumdurchläufe

Ein Tiefensuchlauf durch einen Baum verwendet einen Stack (eine Tabelle als Upvalue), um den Traversierungszustand zu verwalten.

local function dfs(root)
  local stack = {root}
  return function()
    if #stack == 0 then return nil end
    local node = table.remove(stack)
    for _, child in ipairs(node.children or {}) do
      stack[#stack+1] = child
    end
    return node
  end
end

Überlegungen zum Speicherverbrauch

Zustandsbehaftete Iteratoren reservieren ein Closure-Objekt. Für extrem enge innere Schleifen kann ein zustandsloser Iterator vorzuziehen sein. Bei komplexen Traversierungen ist die Closure den zusätzlichen Aufwand jedoch wert.

Vergleich: zustandsbehaftet und zustandslos

  • Zustandsbehaftet: komplexer Zustand, beliebige Traversierungsreihenfolge, einfach zu schreiben.
  • Zustandslos: einfacher sequenzieller Zugriff, keine Speicherreservierung, schnell.

Frage zu zustandsbehafteten Iteratoren

Wo speichert ein zustandsbehafteter Closure-Iterator seinen Zustand?

Zusammenfassung: Zustandsbehaftete Iteratoren

Closure-basierte zustandsbehaftete Iteratoren speichern komplexe Traversierungszustände in Upvalues. Dadurch werden Filter, Mappings, Bäume und verzögerte Pipelines ermöglicht – alles kombinierbar und speichereffizient.

Häufig gestellte Fragen

Ist die Lektion „Zustandsbehaftete Iteratoren mit Closures“ kostenlos?

Ja — der vollständige Text von „Zustandsbehaftete Iteratoren mit Closures“ 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 „Zustandsbehaftete Iteratoren mit Closures“?

Erstellen Sie Iteratoren, die mit Closures ihren Zustand zwischen Aufrufen bewahren 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 3 von 4.

Wie lange dauert die Lektion „Zustandsbehaftete Iteratoren mit Closures“?

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