Lua Academy · Les

Gedeelde upvalues tussen closures

Leer hoe meerdere closures dezelfde upvalue delen en wat de gevolgen van mutatie zijn

Les 2 van 413 stappen

Gedeelde upvalues tussen closures is een gratis Lua Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Dezelfde upvalue delen

Twee closures die in hetzelfde bereik zijn gedefinieerd, kunnen exact dezelfde upvaluecel delen. Wijzigingen door de ene closure zijn zichtbaar voor de andere.

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

Waarom delen plaatsvindt

Lua maakt geen kopie van upvalues per closure. Alle closures die in hetzelfde blok zijn gemaakt en naar dezelfde lokale variabele verwijzen, delen één upvaluecel.

Observerpatroon via een gedeelde upvalue

Een gedeelde upvalue kan fungeren als berichtenbus tussen meerdere closures.

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

Valkuil bij lusvariabelen

In een numeric for-lus wordt bij elke iteratie een nieuwe lokale lusvariabele gemaakt, waardoor closures onafhankelijke upvalues vastleggen.

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)

Valkuil bij een while-lusvariabele

In een while-lus delen alle closures dezelfde upvalue en zien ze de uiteindelijke waarde als je één veranderende variabele vastlegt.

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!)

Een nieuwe lokale variabele vastleggen

Als je onafhankelijke waarden in een while-lus wilt vastleggen, maak je binnen de lusbody een nieuwe lokale variabele aan.

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

Modulepatroon met gedeelde toestand

Een module kan meerdere functies beschikbaar maken die via upvalues een private toestandstabel delen.

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 en wijzigingen

Let op: alle closures die naar dezelfde upvalue verwijzen, zien dezelfde wijziging onmiddellijk. Dit is krachtig, maar kan onbedoelde onderlinge afhankelijkheid veroorzaken.

Identiteit van een upvalue

debug.upvalueid(f, n) retourneert de unieke identiteit van de nde upvalue van functie f. Twee closures met dezelfde upvalue-ID delen dezelfde cel.

debug.upvaluejoin

debug.upvaluejoin(f1, n1, f2, n2) zorgt ervoor dat de nde upvalue van f1 dezelfde cel deelt als de nde upvalue van f2. Dit is een hulpmiddel op laag niveau voor foutopsporing.

Praktische patronen

Getter-/setterparen die een private variabele delen.
Gebeurtenissenteller met een resetfunctie die via meerdere closures beschikbaar is.
Modulestatus die door meerdere API-functies wordt gedeeld.

Vraag over gedeelde upvalues

Twee closures, get en set, worden in hetzelfde bereik gemaakt en leggen allebei value vast. Als set(99) wordt aangeroepen, wat retourneert get() dan?

Beantwoord dit in de interactieve les

Samenvatting: gedeelde upvalues

Closures in hetzelfde bereik delen upvaluecellen. Wijzigingen zijn onmiddellijk zichtbaar voor alle closures die de cel delen. Dit vormt de basis voor inkapseling en modulestatus in Lua.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Gedeelde upvalues tussen closures” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Gedeelde upvalues tussen closures”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “Gedeelde upvalues tussen closures”?

Leer hoe meerdere closures dezelfde upvalue delen en wat de gevolgen van mutatie zijn Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Gedeelde upvalues tussen closures”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Lua Academy