Lua Academy · Les

Meervoudige retourwaarden

Retourneer meerdere waarden vanuit één functieaanroep en vang ze op

Les 2 van 412 stappen

Meervoudige retourwaarden 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.

Meerdere waarden retourneren

In tegenstelling tot de meeste talen kunnen Lua-functies standaard meerdere waarden retourneren vanuit één return-instructie. Meerdere waarden worden na return gescheiden door komma's. Daardoor zijn wrapperobjecten of uitvoerparameters niet nodig.

local function divmod(a, b)
  return math.floor(a / b), a % b
end

local quotient, remainder = divmod(17, 5)
print(quotient, remainder)   -- 3  2

Retourwaarden aanpassen

Lua past retourwaarden aan het aantal ontvangers aan. Overtollige waarden worden genegeerd; ontbrekende waarden worden nil. Deze aanpassing gebeurt wanneer een functieaanroep niet de laatste expressie in een lijst is — op die positie wordt alleen de eerste waarde behouden.

local function triple()
  return 10, 20, 30
end

local a, b, c = triple()
print(a, b, c)      -- 10  20  30

local x, y = triple()
print(x, y)         -- 10  20  (30 discarded)

local p = triple()
print(p)            -- 10  (only first when 1 var)

Aanpassing op een middelste positie

Wanneer een functieaanroep in het midden van een expressielijst staat (dus niet op de laatste positie), reduceert Lua de aanroep tot één waarde. Alleen de laatste expressie in de lijst kan meerdere waarden opleveren.

local function pair()
  return 1, 2
end

-- pair() in middle: only 1 value used
local t = {pair(), pair()}
print(#t, t[1], t[2], t[3])  -- 3  1  1  2
-- first pair() gives just 1; last pair() gives 1,2

-- pair() at end: all values used
local t2 = {10, pair()}
print(#t2, t2[1], t2[2], t2[3])  -- 3  10  1  2

Haakjes dwingen één waarde af

Als je een functieaanroep tussen haakjes zet, dwing je af dat deze precies één waarde retourneert. Dit is handig wanneer je alleen de eerste retourwaarde wilt, ongeacht hoeveel waarden de functie oplevert.

local function coords()
  return 10, 20, 30
end

print(coords())    -- 10  20  30  (all three)
print((coords()))  -- 10  (parentheses: single value only)

local x = (coords())
print(x)           -- 10

Retourwaarden van string.find

Veel functies uit de standaardbibliotheek gebruiken meerdere retourwaarden. string.find retourneert de begin- en eindposities van een overeenkomst (plus vastgelegde waarden). math.modf retourneert het gehele en het gebroken deel. Als je deze patronen begrijpt, kun je de standaardbibliotheek vloeiend gebruiken.

local s = "hello world"
local start, finish = string.find(s, "world")
print(start, finish)   -- 7  11

-- math.modf: integer and fractional parts
local int, frac = math.modf(3.75)
print(int, frac)       -- 3   0.75

Waarden vastleggen met table.pack

table.pack(...) legt alle argumenten (of retourwaarden via ...) vast in een tabel. De tabel bevat een veld n met het totale aantal, inclusief nil-waarden. Zo blijft het exacte aantal behouden, in tegenstelling tot #, dat stopt bij het eerste gat.

local function getData()
  return "Alice", 30, nil, true
end

local t = table.pack(getData())
print(t.n)         -- 4
print(t[1])        -- Alice
print(t[2])        -- 30
print(t[3])        -- nil
print(t[4])        -- true

table.unpack gebruiken om waarden uit te spreiden

table.unpack(t, i, j) retourneert de elementen van een tabel als afzonderlijke waarden. Het is het omgekeerde van table.pack. Gebruik het om de inhoud van een tabel als argumenten aan een functie door te geven of om waarden in een return-instructie uit te spreiden.

local args = {10, 20, 30}

local function sum3(a, b, c)
  return a + b + c
end

print(sum3(table.unpack(args)))  -- 60

-- Use in return
local function passThrough(t)
  return table.unpack(t)
end
print(passThrough({5, 6, 7}))   -- 5  6  7

Retourwaarden voor fouten

Een veelgebruikte Lua-conventie is om bij een fout nil, errorMessage te retourneren en bij succes het resultaat. Aanroepers controleren de eerste retourwaarde: als die nil is, is er een fout opgetreden. Zo vermijd je uitzonderingen bij verwachte foutgevallen.

local function openConfig(path)
  local f = io.open(path, "r")
  if not f then
    return nil, "cannot open: " .. path
  end
  local content = f:read("*a")
  f:close()
  return content
end

local data, err = openConfig("config.lua")
if not data then
  print("Error:", err)
end

Waarden omwisselen met meerdere retourwaarden

Meerdere retourwaarden lossen het probleem van waarden omwisselen elegant op. De rechterkant wordt vóór de toewijzing geëvalueerd, dus a, b = b, a wisselt de waarden correct om zonder tijdelijke variabele.

local a, b = 5, 10
print(a, b)   -- 5  10

a, b = b, a
print(a, b)   -- 10  5

-- Works for three-way rotation too
local x, y, z = 1, 2, 3
x, y, z = z, x, y
print(x, y, z)  -- 3  1  2

Retourconventie van pcall

pcall(f, ...) gebruikt zelf meerdere retourwaarden: de eerste waarde is een boolean (true bij succes, false bij een fout), en de daaropvolgende waarden zijn de retourwaarden van f of het foutbericht. Controleer altijd de eerste retourwaarde voordat je de rest gebruikt.

local function risky(x)
  if x < 0 then error("negative input") end
  return math.sqrt(x)
end

local ok, result = pcall(risky, 16)
print(ok, result)   -- true  4.0

ok, result = pcall(risky, -1)
print(ok, result)   -- false  input:2: negative input

Korte controle

Wat geeft print((string.find("hello", "ll"))) als uitvoer?

Beantwoord dit in de interactieve les

Terugblik: meerdere retourwaarden

Belangrijkste inzichten:

Retourneer meerdere waarden: return a, b, c
Overtollige waarden worden genegeerd; ontbrekende waarden worden nil
Aanroepen op een middelste positie worden tot één waarde teruggebracht
(f()) dwingt precies één waarde af
table.pack/table.unpack voor dynamische waardelijsten
Conventie: retourneer nil, errmsg bij een fout

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 “Meervoudige retourwaarden” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Meervoudige retourwaarden”, 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 “Meervoudige retourwaarden”?

Retourneer meerdere waarden vanuit één functieaanroep en vang ze op 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 “Meervoudige retourwaarden”?

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