Lua Academy · Les

Varargs en de ...-operator

Verwerk argumentlijsten met variabele lengte met behulp van ... en select()

Les 3 van 412 stappen

Varargs en de ...-operator is een gratis Lua Academy-les op CoddyKit. Dit is les 3 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.

Variabel aantal argumenten

Een Lua-functie kan een variabel aantal argumenten accepteren met ... (drie punten) in de parameterlijst. Binnen de functie staan ... voor de extra argumenten. Je kunt ze in expressies gebruiken, aan andere functies doorgeven of naar een tabel omzetten.

local function sum(...)
  local total = 0
  for _, v in ipairs({...}) do
    total = total + v
  end
  return total
end

print(sum(1, 2, 3))        -- 6
print(sum(10, 20, 30, 40)) -- 100

select() voor variabele argumenten

select(n, ...) retourneert de argumenten vanaf positie n. select("#", ...) retourneert het totale aantal argumenten, inclusief nil-waarden. Dit is veiliger dan #{...}, dat stopt bij het eerste gat met nil.

local function inspect(...)
  local n = select("#", ...)
  print("count:", n)
  for i = 1, n do
    print(i, select(i, ...))
  end
end

inspect("a", "b", nil, "d")
-- count: 4
-- 1  a
-- 2  b
-- 3  nil
-- 4  d

... doorgeven aan een andere functie

Je kunt variabele argumenten rechtstreeks doorgeven aan een andere functie met f(...). Wanneer ... het laatste argument in een aanroep is, worden alle variabele argumenten doorgegeven. Dit is handig voor wrapperfuncties of logging.

local function log(level, ...)
  io.write("[" .. level .. "] ")
  print(...)
end

log("INFO", "Server started on port", 8080)
log("ERROR", "File not found:", "config.lua")
-- [INFO] Server started on port  8080
-- [ERROR] File not found:  config.lua

table.pack en table.unpack

Zet variabele argumenten om naar een tabel met table.pack(...), dat het aantal ook opslaat in veld n. Zet een tabel weer om naar variabele argumenten met table.unpack(t, i, j). Samen geven deze functies je volledige controle over lijsten met een variabel aantal argumenten.

local function pack_and_show(...)
  local packed = table.pack(...)
  print("n =", packed.n)
  for i = 1, packed.n do
    print(i, packed[i])
  end
end

pack_and_show(10, nil, 30)
-- n = 3
-- 1  10
-- 2  nil
-- 3  30

Vaste en variabele argumenten combineren

Een functie kan zowel vaste als variabele parameters hebben. Vaste parameters komen eerst; ... legt de rest vast. De vaste parameters worden toegewezen voordat de overige argumenten in ... terechtkomen.

local function printf(fmt, ...)
  io.write(string.format(fmt, ...))
end

printf("Hello, %s! You are %d years old.\n", "Alice", 30)
printf("Pi is approximately %.4f\n", math.pi)

local function firstAndRest(first, ...)
  print("first:", first)
  print("rest count:", select("#", ...))
end
firstAndRest(1, 2, 3, 4)

Variabele argumenten in een tabelconstructor

Je kunt variabele argumenten rechtstreeks in een tabelconstructor uitspreiden: {...}. Als dit het laatste element is, worden alle argumenten opgenomen. Gaten met nil kunnen # echter in de war brengen — gebruik table.pack als je exacte aantallen nodig hebt.

local function toArray(...)
  return {...}  -- collect all args as array
end

local arr = toArray("x", "y", "z")
for i, v in ipairs(arr) do
  print(i, v)
end
-- 1  x
-- 2  y
-- 3  z

Expressies met variabele argumenten

... kan op elke positie in een expressie staan. Bij een meervoudige toewijzing wordt het uitgebreid naar al zijn waarden. In een rekenkundige expressie wordt alleen de eerste waarde gebruikt. Als je dit gedrag begrijpt, voorkom je subtiele fouten bij het combineren van ... met andere expressies.

local function first(...)
  local x = ...
  return x
end

print(first(10, 20, 30))  -- 10  (only first)

local function addFirst(n, ...)
  local x = ...
  return n + x
end
print(addFirst(5, 3, 99)) -- 8  (3 is first ...)

print() gebruikt variabele argumenten

De ingebouwde functie print() van Lua is zelf een functie met een variabel aantal argumenten. De functie accepteert elk aantal argumenten, zet elk argument om naar een tekenreeks en scheidt ze met tabs. Als je dit begrijpt, kun je vergelijkbare hulpfuncties schrijven.

-- print is vararg
print(1, 2, 3)           -- 1  2  3
print("a", nil, "b")     -- a  nil  b
print()                  -- (empty line)

-- Reimplementing a simple print-like function
local function myprint(...)
  local parts = {}
  for i = 1, select("#", ...) do
    parts[i] = tostring(select(i, ...))
  end
  io.write(table.concat(parts, "\t") .. "\n")
end
myprint(10, nil, 30)

Doorgeven met pcall

Combineer pcall met variabele argumenten om een algemene wrapper voor veilige functieaanroepen te maken. De wrapper accepteert een functie en willekeurige argumenten, roept de functie aan via pcall en retourneert de resultaten of een fout.

local function safeCall(fn, ...)
  local ok, result = pcall(fn, ...)
  if ok then
    return result
  else
    print("Error:", result)
    return nil
  end
end

local function divide(a, b)
  assert(b ~= 0, "division by zero")
  return a / b
end

print(safeCall(divide, 10, 2))   -- 5.0
print(safeCall(divide, 10, 0))  -- Error: ...

Patroon voor het verzamelen van variabele argumenten

Een veelgebruikt patroon met variabele argumenten is alle argumenten doorlopen en een resultaat verzamelen. Dit kan met een lokale tabel of door rechtstreeks op te tellen met select. Beide aanpakken zijn geldig; de tabelaanpak is overzichtelijker bij veel argumenten.

local function average(...)
  local n = select("#", ...)
  if n == 0 then return 0 end
  local total = 0
  for i = 1, n do
    total = total + select(i, ...)
  end
  return total / n
end

print(average(10, 20, 30, 40))  -- 25.0
print(average(5))               -- 5.0

Korte controle

Wat retourneert select("#", 1, nil, 3)?

Beantwoord dit in de interactieve les

Terugblik: variabele argumenten

Samenvatting:

function f(...) — accepteert een variabel aantal argumenten
select("#", ...) — veilige telling inclusief nil-waarden
select(n, ...) — waarden vanaf positie n
table.pack(...) — variabele argumenten naar een tabel met telling in .n
table.unpack(t) — tabel naar variabele argumenten
... op de laatste positie wordt volledig uitgebreid; op een middelste positie levert het één waarde op

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 “Varargs en de ...-operator” gratis?

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

Verwerk argumentlijsten met variabele lengte met behulp van ... en select() 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 3 van 4.

Hoe lang duurt de les “Varargs en de ...-operator”?

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