Lua Academy · Lektion

Mehrere Rückgabewerte

Geben Sie mehrere Werte aus einem einzigen Funktionsaufruf zurück und übernehmen Sie diese

Mehrere Rückgabewerte 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.

Mehrere Werte zurückgeben

Im Gegensatz zu den meisten Programmiersprachen können Lua-Funktionen nativ mehrere Werte mit einer einzigen return-Anweisung zurückgeben. Mehrere Werte werden nach return durch Kommas getrennt. Dadurch sind keine Wrapper-Objekte oder Ausgabeparameter erforderlich.

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

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

Rückgabewerte anpassen

Lua passt Rückgabewerte an die Anzahl der Empfänger an. Überzählige Werte werden verworfen, fehlende Werte werden zu nil. Diese Anpassung erfolgt immer dann, wenn ein Funktionsaufruf nicht der letzte Ausdruck in einer Liste ist — an dieser Position wird nur der erste Wert übernommen.

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)

Anpassung an mittlerer Position

Wenn ein Funktionsaufruf in der Mitte einer Ausdrucksliste steht (also nicht an der letzten Position), kürzt Lua ihn auf einen einzelnen Wert. Nur der letzte Ausdruck der Liste kann mehrere Werte liefern.

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

Klammern erzwingen einen einzelnen Wert

Wenn Sie einen Funktionsaufruf in Klammern setzen, wird er gezwungen, genau einen Wert zurückzugeben. Das ist nützlich, wenn Sie unabhängig von der Anzahl der von der Funktion erzeugten Werte nur den ersten Rückgabewert benötigen.

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

Rückgabewerte von string.find

Viele Funktionen der Standardbibliothek verwenden mehrere Rückgabewerte. string.find gibt die Start- und Endpositionen eines Treffers (sowie Captures) zurück. math.modf gibt den ganzzahligen und den gebrochenen Anteil zurück. Wenn Sie diese Muster verstehen, können Sie die Standardbibliothek sicher verwenden.

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

Werte mit table.pack erfassen

table.pack(...) erfasst alle Argumente (oder über ... übergebenen Rückgabewerte) in einer Tabelle. Die Tabelle enthält ein Feld n mit der Gesamtanzahl, einschließlich nil-Werten. Dadurch bleibt die genaue Anzahl erhalten, anders als bei #, das beim ersten Lückenwert stoppt.

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 zum Aufteilen

table.unpack(t, i, j) gibt die Elemente einer Tabelle als einzelne Werte zurück. Es ist das Gegenstück zu table.pack. Verwenden Sie es, um den Inhalt einer Tabelle als Argumente an eine Funktion zu übergeben oder Werte in einer return-Anweisung aufzuteilen.

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

Rückgaben nach dem Fehlermuster

Eine verbreitete Lua-Konvention ist, bei einem Fehler nil, errorMessage und bei Erfolg das Ergebnis zurückzugeben. Aufrufer prüfen den ersten Rückgabewert: Ist er nil, ist ein Fehler aufgetreten. Dadurch lassen sich Ausnahmen bei erwartbaren Fehlerfällen vermeiden.

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

Werte mit mehreren Rückgaben vertauschen

Mehrere Rückgabewerte lösen das Vertauschen von Werten elegant. Die rechte Seite wird vor der Zuweisung ausgewertet, daher vertauscht a, b = b, a die Werte korrekt, ohne eine temporäre Variable zu benötigen.

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

Rückgabekonvention von pcall

pcall(f, ...) selbst verwendet mehrere Rückgabewerte: Der erste Wert ist ein boolescher Wert (true bei Erfolg, false bei einem Fehler), die nachfolgenden Werte sind entweder die Rückgabewerte von f oder die Fehlermeldung. Prüfen Sie immer den ersten Rückgabewert, bevor Sie die übrigen verwenden.

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

Kurze Überprüfung

Was gibt print((string.find("hello", "ll"))) aus?

Rückblick: Mehrere Rückgabewerte

Die wichtigsten Erkenntnisse:

Mehrere Werte zurückgeben: return a, b, c
Überzählige Werte werden verworfen, fehlende zu nil
Aufrufe an mittlerer Position werden auf einen Wert gekürzt
(f()) erzwingt genau einen Wert
table.pack/table.unpack für dynamische Wertelisten
Konvention: bei einem Fehler nil, errmsg zurückgeben

Häufig gestellte Fragen

Ist die Lektion „Mehrere Rückgabewerte“ kostenlos?

Ja — der vollständige Text von „Mehrere Rückgabewerte“ 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 „Mehrere Rückgabewerte“?

Geben Sie mehrere Werte aus einem einzigen Funktionsaufruf zurück und übernehmen Sie diese 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 „Mehrere Rückgabewerte“?

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