0Pricing
Lua Academy · Lektion

Gemeinsam genutzte Upvalues zwischen Closures

Verstehen Sie mehrere Closures, die dasselbe Upvalue verwenden, sowie die Auswirkungen von Änderungen

Gemeinsam genutzte Upvalues zwischen Closures ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Dasselbe Upvalue gemeinsam verwenden

Zwei im selben Scope definierte Closures können exakt dieselbe Upvalue-Zelle gemeinsam verwenden. Änderungen durch die eine Closure sind für die andere sichtbar.

local function makeGetterSetter()
  local value = 0
  local function get() return value end
  local function set(v) value = v end
  return get, set
end
local get, set = makeGetterSetter()
set(42)
print(get())  -- 42

Warum gemeinsam verwendet wird

Lua erstellt keine Kopien von Upvalues für jede Closure. Alle Closures, die im selben Block erstellt wurden und auf dieselbe lokale Variable verweisen, teilen sich eine Upvalue-Zelle.

Observer-Muster mit gemeinsamem Upvalue

Ein gemeinsam verwendetes Upvalue kann als Nachrichtenbus zwischen mehreren Closures dienen.

local count = 0
local inc = function() count = count + 1 end
local dec = function() count = count - 1 end
local get = function() return count end
inc(); inc(); dec()
print(get())  -- 1

Stolperfalle bei Schleifenvariablen

In einer numeric for-Schleife wird bei jeder Iteration eine neue lokale Schleifenvariable erstellt. Daher erfassen Closures unabhängige Upvalues.

local fns = {}
for i = 1, 3 do
  fns[i] = function() return i end
end
print(fns[1](), fns[2](), fns[3]())  -- 1 2 3 (each closure has its own i)

Stolperfalle bei der while-Schleifenvariablen

In einer while-Schleife teilen sich alle Closures dasselbe Upvalue und sehen den endgültigen Wert, wenn Sie eine einzelne, veränderte Variable erfassen.

local fns = {}
local i = 0
while i < 3 do
  i = i + 1
  fns[i] = function() return i end  -- all share same i!
end
print(fns[1]())  -- 3 (not 1!)

Eine neue lokale Variable erfassen

Um in einer while-Schleife unabhängige Werte zu erfassen, führen Sie innerhalb des Schleifenkörpers eine neue lokale Variable ein.

local fns = {}
local i = 0
while i < 3 do
  i = i + 1
  local ci = i  -- new local per iteration
  fns[i] = function() return ci end
end
print(fns[1]())  -- 1, fns[2]() == 2

Muster für Module mit gemeinsamem Zustand

Ein Modul kann mehrere Funktionen bereitstellen, die über Upvalues eine private Zustandstabelle gemeinsam verwenden.

local function makeStack()
  local data = {}
  return {
    push = function(v) data[#data+1] = v end,
    pop  = function() local v = data[#data]; data[#data]=nil; return v end,
    size = function() return #data end,
  }
end

Aliasing und Änderungen

Vorsicht: Alle Closures, die auf dasselbe Upvalue verweisen, sehen dieselbe Änderung sofort. Das ist leistungsfähig, kann aber zu unbeabsichtigter Kopplung führen.

Identität eines Upvalues

debug.upvalueid(f, n) gibt die eindeutige Identität des n-ten Upvalues der Funktion f zurück. Zwei Closures mit derselben Upvalue-ID teilen dieselbe Zelle.

debug.upvaluejoin

debug.upvaluejoin(f1, n1, f2, n2) bewirkt, dass das n-te Upvalue von f1 dieselbe Zelle wie das n2-te Upvalue von f2 verwendet. Ein Werkzeug auf niedriger Ebene zum Debuggen.

Praktische Muster

  • Getter-/Setter-Paare, die eine private Variable gemeinsam verwenden.
  • Ereigniszähler mit einer über mehrere Closures bereitgestellten Zurücksetzung.
  • Modulzustand, der von mehreren API-Funktionen gemeinsam verwendet wird.

Frage zu gemeinsam verwendeten Upvalues

Die beiden Closures get und set werden im selben Scope erstellt und erfassen beide value. Was gibt get() zurück, wenn set(99) aufgerufen wird?

Zusammenfassung: Gemeinsam verwendete Upvalues

Closures im selben Scope teilen Upvalue-Zellen. Änderungen sind für alle Closures, die sie gemeinsam verwenden, sofort sichtbar. Das bildet die Grundlage für Kapselung und Modulzustand in Lua.

Häufig gestellte Fragen

Ist die Lektion „Gemeinsam genutzte Upvalues zwischen Closures“ kostenlos?

Ja — der vollständige Text von „Gemeinsam genutzte Upvalues zwischen 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 „Gemeinsam genutzte Upvalues zwischen Closures“?

Verstehen Sie mehrere Closures, die dasselbe Upvalue verwenden, sowie die Auswirkungen von Änderungen 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 2 von 4.

Wie lange dauert die Lektion „Gemeinsam genutzte Upvalues zwischen 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. Was sind Upvalues?
  2. Gemeinsam genutzte Upvalues zwischen Closures
  3. Factory-Funktionen und Generatoren
  4. Memoisierung mit Closures
← Zurück zu Lua Academy