Lua Academy · Lektion

Memoisierung mit Closures

Cachen Sie aufwendige Funktionsergebnisse in einer von einer Closure verwalteten Tabelle

Memoisierung mit Closures 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.

Was ist Memoization?

Memoization speichert die Ergebnisse aufwendiger Funktionsaufrufe zwischen, sodass wiederholte Aufrufe mit denselben Argumenten sofort das zwischengespeicherte Ergebnis zurückgeben.

Einfacher Memoize-Wrapper

Eine Closure enthält eine cache-Tabelle. Beim ersten Aufruf wird das Ergebnis berechnet und gespeichert. Bei weiteren Aufrufen wird der gespeicherte Wert zurückgegeben.

local function memoize(fn)
  local cache = {}
  return function(x)
    if cache[x] == nil then
      cache[x] = fn(x)
    end
    return cache[x]
  end
end

Memoizierte Fibonacci-Funktion

Die Memoization der rekursiven Fibonacci-Funktion reduziert ihre Zeitkomplexität von exponentiell auf linear.

local fib
fib = memoize(function(n)
  if n <= 1 then return n end
  return fib(n-1) + fib(n-2)
end)
print(fib(30))  -- 832040 (fast!)

Memoization mit mehreren Argumenten

Bei Funktionen mit mehreren Argumenten erstellen Sie aus allen Argumenten eine Zeichenfolge als Cache-Schlüssel.

local function memoize2(fn)
  local cache = {}
  return function(a, b)
    local key = a .. "," .. b
    if cache[key] == nil then cache[key] = fn(a, b) end
    return cache[key]
  end
end

Verschachtelte Cache-Tabellen

Verwenden Sie bei gemischten Argumenttypen verschachtelte Tabellen, die nach jedem Argument indiziert werden. So erhalten Sie eine Suche in O(1), ohne Zeichen zu serialisieren.

local function nestedMemo(fn)
  local cache = {}
  return function(a, b)
    cache[a] = cache[a] or {}
    if cache[a][b] == nil then cache[a][b] = fn(a, b) end
    return cache[a][b]
  end
end

Cache-Invalidierung

Memoization setzt reine Funktionen voraus (keine Seiteneffekte, gleiche Ausgabe bei gleicher Eingabe). Funktionen mit Seiteneffekten sollten ohne sorgfältige Cache-Invalidierung nicht memoisiert werden.

Memoization mit TTL

Fügen Sie mithilfe von os.time() eine Time-to-Live-Logik hinzu, um zwischengespeicherte Einträge ablaufen zu lassen.

local function memoizeTTL(fn, ttl)
  local cache = {}
  return function(x)
    local entry = cache[x]
    if entry and os.time() - entry.time < ttl then
      return entry.value
    end
    cache[x] = {value = fn(x), time = os.time()}
    return cache[x].value
  end
end

Cache mit schwachen Werten

Verwenden Sie schwache Werte, damit zwischengespeicherte Ergebnisse bei knappem Speicher vom Garbage Collector freigegeben werden können.

local function memoizeWeak(fn)
  local cache = setmetatable({}, {__mode = "v"})
  return function(x)
    if cache[x] == nil then cache[x] = fn(x) end
    return cache[x]
  end
end

Muster für rekursive Memoization

Weisen Sie bei gegenseitig rekursiven Funktionen den memoisierten Wrapper zu, bevor der rekursive Körper ihn verwendet, damit die Rekursion den Cache nutzt.

Begrenzter Cache (LRU-Skizze)

Implementieren Sie zur Speicherbegrenzung einen LRU-Cache, der den am längsten nicht verwendeten Eintrag entfernt, sobald der Cache eine maximale Größe überschreitet.

Memoization in der Praxis

Häufige Einsatzbereiche sind aufwendige mathematische Berechnungen, das Caching von Datenbankabfrageergebnissen, die Kompilierung von Lua-Mustern und das Parsen von Konfigurationsdateien.

Frage zur Memoization

Warum sollte Memoization nur auf reine Funktionen angewendet werden?

Zusammenfassung: Memoization

Memoization verwendet einen von einer Closure gehaltenen Cache, um Ergebnisse nach Argument-Schlüsseln zu speichern und überflüssige Berechnungen zu vermeiden. Verwenden Sie für Speichersicherheit schwache Tabellen und fügen Sie für zeitabhängige Caches eine TTL hinzu.

Häufig gestellte Fragen

Ist die Lektion „Memoisierung mit Closures“ kostenlos?

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

Cachen Sie aufwendige Funktionsergebnisse in einer von einer Closure verwalteten Tabelle 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 „Memoisierung 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

Was sind Upvalues?
Gemeinsam genutzte Upvalues zwischen Closures
Factory-Funktionen und Generatoren
Memoisierung mit Closures

← Zurück zu Lua Academy