Lua Academy · Lektion

Varargs und der ...-Operator

Verarbeiten Sie Argumentlisten variabler Länge mit ... und select()

Varargs und der ...-Operator ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Variable Argumente

Eine Lua-Funktion kann mithilfe von ... (drei Punkten) in der Parameterliste eine variable Anzahl von Argumenten akzeptieren. Innerhalb der Funktion steht ... für die zusätzlichen Argumente. Sie können es in Ausdrücken verwenden, an andere Funktionen übergeben oder in eine Tabelle umwandeln.

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() für Varargs

select(n, ...) gibt die Argumente ab Position n zurück. select("#", ...) gibt die Gesamtanzahl der Argumente einschließlich nil-Werten zurück. Das ist sicherer als #{...}, das beim ersten nil-Lückenwert stoppt.

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

... an eine andere Funktion übergeben

Sie können Varargs mit f(...) direkt an eine andere Funktion weiterleiten. Wenn ... als letztes Argument eines Aufrufs steht, werden alle variablen Argumente übergeben. Das ist nützlich für Wrapper-Funktionen oder Protokollierung.

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 und table.unpack

Wandeln Sie Varargs mit table.pack(...) in eine Tabelle um; dabei wird die Anzahl im Feld n gespeichert. Mit table.unpack(t, i, j) wandeln Sie eine Tabelle zurück in Varargs um. Zusammen geben Ihnen diese Funktionen vollständige Kontrolle über Listen variabler Argumente.

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

Feste und variable Argumente kombinieren

Eine Funktion kann sowohl feste als auch variable Parameter haben. Die festen Parameter stehen zuerst; ... erfasst den Rest. Die festen Parameter werden zugewiesen, bevor die übrigen Argumente in ... übernommen werden.

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)

Varargs im Tabellenkonstruktor

Sie können Varargs direkt in einen TabellKonstruktor einsetzen: {...}. Bei Verwendung als letztes Element werden alle Argumente aufgenommen. nil-Lücken können jedoch # verwirren — verwenden Sie table.pack, wenn Sie genaue Anzahlen benötigen.

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

Vararg-Ausdrücke

... kann an jeder Position eines Ausdrucks stehen. Bei einer Mehrfachzuweisung wird es auf alle seine Werte erweitert. In einem arithmetischen Ausdruck wird nur der erste Wert verwendet. Wenn Sie dieses Verhalten verstehen, vermeiden Sie subtile Fehler beim Kombinieren von ... mit anderen Ausdrücken.

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() verwendet Varargs

Das eingebaute Lua-print() ist selbst eine Vararg-Funktion. Es akzeptiert eine beliebige Anzahl von Argumenten, wandelt jedes in einen String um und trennt sie durch Tabulatoren. Dieses Verständnis hilft Ihnen, ähnliche Hilfsfunktionen zu schreiben.

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

Weiterleiten mit pcall

Kombinieren Sie pcall mit Varargs, um einen generischen Wrapper für sichere Aufrufe zu erstellen. Der Wrapper akzeptiert eine Funktion und beliebige Argumente, ruft sie über pcall auf und gibt die Ergebnisse oder einen Fehler zurück.

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: ...

Muster zum Akkumulieren von Varargs

Ein verbreitetes Vararg-Muster besteht darin, über alle Argumente zu iterieren und ein Ergebnis zu akkumulieren. Das lässt sich mit einer lokalen Tabelle oder durch direktes Aufsummieren mithilfe von select umsetzen. Beide Ansätze sind gültig; für viele Argumente ist der Tabellenansatz übersichtlicher.

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

Kurze Überprüfung

Was gibt select("#", 1, nil, 3) zurück?

Rückblick: Varargs

Zusammenfassung:

function f(...) — akzeptiert variable Argumente
select("#", ...) — sichere Zählung einschließlich nil-Werten
select(n, ...) — Werte ab Position n
table.pack(...) — Varargs als Tabelle mit der Anzahl in .n
table.unpack(t) — Tabelle als Varargs
... an letzter Position wird vollständig erweitert; an mittlerer Position ergibt es einen Wert

Häufig gestellte Fragen

Ist die Lektion „Varargs und der ...-Operator“ kostenlos?

Ja — der vollständige Text von „Varargs und der ...-Operator“ 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 „Varargs und der ...-Operator“?

Verarbeiten Sie Argumentlisten variabler Länge mit ... und select() 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 3 von 4.

Wie lange dauert die Lektion „Varargs und der ...-Operator“?

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

← Zurück zu Lua Academy