Lua Academy · Lektion

Funktionen definieren und aufrufen

Lernen Sie die Syntax für Funktionsdeklarationen, Aufrufkonventionen sowie lokale und globale Funktionen kennen

Funktionen definieren und aufrufen ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Funktionssyntax

Funktionen werden in Lua mit dem Schlüsselwort function definiert. Der Rumpf ist ein Block, der mit end abgeschlossen wird. Funktionen können global oder lokal sein. Sie rufen eine Funktion auf, indem Sie Klammern mit Argumenten anhängen. Wenn Sie Argumente weglassen, erhalten fehlende Parameter den Wert nil.

function sayHello(name)
  print("Hello, " .. (name or "World") .. "!")
end

sayHello("Lua")   -- Hello, Lua!
sayHello()        -- Hello, World!

local function add(a, b)
  return a + b
end
print(add(3, 4))  -- 7

Rückgabewerte

Funktionen geben Werte mit return zurück. Anders als in den meisten Sprachen können Lua-Funktionen mehrere Werte zurückgeben. Wenn Sie keine Rückgabe angeben, gibt die Funktion nichts zurück (null Werte). Überschüssige Rückgabewerte werden verworfen, wenn der Aufruf nicht der letzte Ausdruck in einer Liste ist.

local function minMax(t)
  local lo, hi = t[1], t[1]
  for i = 2, #t do
    if t[i] < lo then lo = t[i] end
    if t[i] > hi then hi = t[i] end
  end
  return lo, hi
end

local lo, hi = minMax({5,2,8,1,9})
print(lo, hi)  -- 1  9

Funktionen als Werte

Funktionen sind in Lua Werte erster Klasse. Sie können sie in Variablen speichern, als Argumente an andere Funktionen übergeben und zurückgeben. Dadurch werden Callbacks, Funktionen höherer Ordnung und funktionale Programmiermuster ermöglicht.

local ops = {
  add = function(a, b) return a + b end,
  sub = function(a, b) return a - b end,
  mul = function(a, b) return a * b end,
}

local function apply(op, a, b)
  return op(a, b)
end

print(apply(ops.add, 10, 3))  -- 13
print(apply(ops.mul, 4, 5))   -- 20

Lokale und globale Funktionen

Verwenden Sie local function für Hilfsfunktionen, die nur innerhalb eines Moduls verfügbar sein sollen. Globale Funktionen verunreinigen den globalen Namensraum und sind von überall aus zugänglich, was zu Namenskonflikten führen kann. Bevorzugen Sie daher in den meisten Fällen lokale Funktionen und stellen Sie über eine Modultabelle nur das bereit, was Sie benötigen.

-- Bad: pollutes global namespace
function helper() end

-- Good: module-local
local function helper()
  return "I am local"
end

-- Module export pattern
local M = {}
function M.publicFunc()
  return helper()  -- can call local
end
return M

Methoden mit Doppelpunktsyntax

Lua bietet syntaktischen Zucker zum Definieren und Aufrufen von Methoden für Tabellen. obj:method(arg) entspricht obj.method(obj, arg). Die Doppelpunktsyntax übergibt die Tabelle implizit als erstes Argument, das üblicherweise self genannt wird.

local Dog = {}
Dog.__index = Dog

function Dog.new(name)
  return setmetatable({name=name}, Dog)
end

function Dog:speak()
  print(self.name .. " says: Woof!")
end

local d = Dog.new("Rex")
d:speak()   -- Rex says: Woof!

Muster für optionale Parameter

Lua verfügt über keine integrierten optionalen Parameter, Sie können sie jedoch mit nil-Prüfungen simulieren. Übergeben Sie bei Funktionen mit vielen optionalen Parametern eine einzelne Optionstabelle – das ist übersichtlicher als eine lange Argumentliste.

local function createUser(name, opts)
  opts = opts or {}
  return {
    name = name,
    role = opts.role or "user",
    active = opts.active ~= false,
    score = opts.score or 0,
  }
end

local u = createUser("Alice", {role="admin", score=100})
print(u.name, u.role, u.score)

Endrekursive Aufrufe

Ein Endaufruf ist ein Funktionsaufruf an der letzten Position, also die letzte Aktion vor der Rückgabe. Lua führt eine Optimierung von Endaufrufen durch: Ein ordnungsgemäßer Endaufruf benötigt keinen zusätzlichen Stack-Speicher. Dadurch ist tiefe Rekursion ohne Stacküberlauf möglich, wenn sich der rekursive Aufruf an der letzten Position befindet.

local function factorial(n, acc)
  acc = acc or 1
  if n <= 1 then return acc end
  return factorial(n - 1, n * acc)  -- tail call!
end

print(factorial(10))  -- 3628800
-- Can handle very large n without stack overflow

Sofort aufgerufene Funktionen

Sie können eine Funktion definieren und sofort aufrufen: (function() ... end)(). Das ist nützlich, um einen lokalen Gültigkeitsbereich zu erstellen, Setup-Code genau einmal auszuführen oder den äußeren Gültigkeitsbereich nicht mit temporären Variablen zu belasten.

local result = (function()
  local temp = 100
  local adjusted = temp * 1.5
  return math.floor(adjusted)
end)()

print(result)   -- 150
-- temp and adjusted not visible here

Funktionen in Tabellen speichern

Das Speichern von Funktionen in Tabellen ist ein idiomatisches Muster beim Entwurf von Lua-Modulen. Die Tabelle dient als Namensraum. Sie definieren Funktionen, indem Sie sie Tabellenfeldern zuweisen oder die Punkt- beziehungsweise Doppelpunktsyntax mit dem Tabellennamen verwenden.

local math2 = {}

function math2.clamp(val, lo, hi)
  return math.max(lo, math.min(hi, val))
end

function math2.lerp(a, b, t)
  return a + (b - a) * t
end

print(math2.clamp(150, 0, 100))  -- 100
print(math2.lerp(0, 10, 0.5))   -- 5.0

Closures als Callbacks

Funktionen höherer Ordnung akzeptieren Callbacks. In Lua sind Callbacks einfach Funktionswerte. Closures eignen sich besonders gut als Callbacks, weil sie den Aufrufkontext erfassen, ohne dass zusätzliche Argumente durch die Funktion höherer Ordnung übergeben werden müssen.

local function forEach(t, fn)
  for i, v in ipairs(t) do
    fn(v, i)
  end
end

local sum = 0
forEach({10, 20, 30}, function(v)
  sum = sum + v
end)
print(sum)   -- 60

forEach({"a","b","c"}, function(v, i)
  print(i, v)
end)

Kurztest

Welche Ausgabe erzeugt local function f() return 1, 2, 3 end; local a, b = f()?

Rückblick: Funktionen

Wichtige Punkte:

Verwenden Sie local function, um globale Variablen nicht zu verunreinigen
Funktionen sind Werte erster Klasse: Sie können in Variablen und Tabellen gespeichert sowie als Argumente übergeben werden
Die Doppelpunkt-Syntax übergibt implizit self
Simulieren Sie optionale Parameter mit opts or {}
Tail Calls verhindern einen Stacküberlauf bei tiefer Rekursion
Sofort aufgerufene Funktionen erzeugen lokale Gültigkeitsbereiche

Häufig gestellte Fragen

Ist die Lektion „Funktionen definieren und aufrufen“ kostenlos?

Ja — der vollständige Text von „Funktionen definieren und aufrufen“ 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 „Funktionen definieren und aufrufen“?

Lernen Sie die Syntax für Funktionsdeklarationen, Aufrufkonventionen sowie lokale und globale Funktionen kennen 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 1 von 4.

Wie lange dauert die Lektion „Funktionen definieren und aufrufen“?

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