Lua Academy · Lektion

Funktionen kombinieren

Verketten Sie Transformationen.

Funktionen kombinieren ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Was ist Komposition?

Bei der Funktionskomposition werden zwei Funktionen zu einer einzigen kombiniert. Die komponierte Funktion leitet ihre Eingabe zunächst durch die erste Funktion und übergibt deren Ergebnis anschließend an die zweite.

In der Mathematik wird dies als f(g(x)) geschrieben. Mit Komposition können Sie aus kleinen, fokussierten Funktionen umfangreiche Transformationen aufbauen.

Zwei Funktionen kombinieren

Eine Hilfsfunktion compose nimmt zwei Funktionen entgegen und gibt eine neue zurück. Ihr Aufruf führt zuerst g aus und übergibt das Ergebnis anschließend an f.

Die Reihenfolge ist entscheidend: Die innere Funktion wird zuerst ausgeführt, die äußere Funktion verarbeitet ihre Ausgabe.

local function compose(f, g)
  return function(x)
    return f(g(x))
  end
end

local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end

local incThenDouble = compose(dbl, inc)
print(incThenDouble(3))

Die Reihenfolge ist wichtig

Wenn Sie die Argumente vertauschen, ändert sich das Ergebnis. compose(f, g) bedeutet, zuerst g und anschließend f anzuwenden.

Das folgende Beispiel zeigt, dass Verdoppeln und anschließendes Erhöhen ein anderes Ergebnis liefert als Erhöhen und anschließendes Verdoppeln.

local function compose(f, g) return function(x) return f(g(x)) end end
local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end

print(compose(dbl, inc)(3))
print(compose(inc, dbl)(3))

String-Funktionen kombinieren

Komposition funktioniert mit beliebigen Funktionen mit einem Argument, auch mit Transformationen von Zeichenketten. Sie können das Entfernen von Leerzeichen, die Änderung der Groß- und Kleinschreibung oder das Umkehren zu einem wiederverwendbaren Schritt verketten.

Hier wird zuerst reverse ausgeführt und anschließend upper, wodurch eine Zeichenkette mit umgekehrter Reihenfolge und Großschreibung entsteht.

local function compose(f, g) return function(x) return f(g(x)) end end

local shout = compose(string.upper, string.reverse)
print(shout("lua"))

Viele Funktionen kombinieren

Um mehr als zwei Funktionen zu verketten, schreiben Sie eine variadische Funktion composeAll. Sie wendet die Funktionen wie bei verschachtelten Aufrufen von rechts nach links an.

Die Schleife durchläuft die Funktionsliste rückwärts und reicht den Wert durch jede Funktion weiter.

local function composeAll(...)
  local fns = {...}
  return function(x)
    for i = #fns, 1, -1 do
      x = fns[i](x)
    end
    return x
  end
end

local f = composeAll(function(n) return n + 1 end,
  function(n) return n * 2 end,
  function(n) return n - 3 end)
print(f(10))

Von rechts nach links

Bei composeAll(a, b, c) wird die Funktion c ganz rechts zuerst ausgeführt, danach b und schließlich a. Das entspricht der verschachtelten Form a(b(c(x))).

Die Reihenfolge kann schwer zu lesen sein. Deshalb bevorzugen manche eine Pipe von links nach rechts.

Eine Pipe von links nach rechts

Eine pipe kehrt die Lesereihenfolge um: Die Funktionen werden von links nach rechts in der angegebenen Reihenfolge ausgeführt. Viele finden das bei Datenpipelines leichter nachzuvollziehen.

Die Schleife läuft vorwärts und wendet jede Funktion auf den aktuellen Wert an.

local function pipe(...)
  local fns = {...}
  return function(x)
    for i = 1, #fns do
      x = fns[i](x)
    end
    return x
  end
end

local process = pipe(function(n) return n + 1 end,
  function(n) return n * 2 end)
print(process(5))

Pipes für bessere Lesbarkeit

Mit pipe werden die Schritte von oben nach unten in ihrer Ausführungsreihenfolge gelesen. Dadurch dokumentieren sich mehrstufige Transformationen praktisch selbst.

Hier wird eine Zeichenkette zuerst von einem Präfix bereinigt, dann in Kleinbuchstaben umgewandelt und anschließend umgekehrt. Jeder Schritt steht in der Reihenfolge, in der er ausgeführt wird.

local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end

local transform = pipe(string.lower, string.reverse,
  function(s) return "[" .. s .. "]" end)
print(transform("LUA"))

Komposition mit Closures

Sie können Funktionen kombinieren, die durch partielle Anwendung oder Closures erstellt wurden. Bauen Sie kleine, spezialisierte Funktionen und verbinden Sie sie anschließend.

So bleibt jeder Bestandteil testbar, während die Komposition den Gesamtablauf ausdrückt.

local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end
local function adder(n) return function(x) return x + n end end
local function muller(n) return function(x) return x * n end end

local calc = pipe(adder(3), muller(10))
print(calc(2))

Komposition und Pipelines

Komposition bildet das Bindeglied hinter Datenpipelines. Statt Aufrufe tief zu verschachteln, benennen Sie eine komponierte Funktion einmal und wenden sie auf viele Eingaben an.

Das funktioniert besonders gut mit map: Übergeben Sie eine komponierte Funktion als Transformation für jedes Element.

local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function compose(f, g) return function(x) return f(g(x)) end end

local step = compose(function(n) return n + 1 end, function(n) return n * n end)
local r = map({1, 2, 3, 4}, step)
print(table.concat(r, ", "))

Halten Sie Funktionen klein

Komposition belohnt kleine Funktionen mit jeweils einem klaren Zweck. Jede erledigt eine Aufgabe, und gemeinsam bilden sie komplexes Verhalten, ohne dass Sie Logik wiederholen müssen.

Das ist der Kern funktionalen Designs: Bauen Sie ein Vokabular aus winzigen Funktionen auf und kombinieren Sie sie, um größere Ideen auszudrücken.

Kurze Überprüfung

Verfolgen Sie die Reihenfolge sorgfältig, bevor Sie antworten.

Zusammenfassung

Bei der Komposition werden Funktionen so kombiniert, dass die Ausgabe der einen Funktion als Eingabe der nächsten dient. compose(f, g) führt g und danach f aus, also von rechts nach links, während pipe aus Gründen der Lesbarkeit von links nach rechts arbeitet.

Mit composeAll und pipe verketten Sie viele kleine Funktionen zu übersichtlichen Pipelines, die besonders in Verbindung mit map leistungsfähig sind.

Häufig gestellte Fragen

Ist die Lektion „Funktionen kombinieren“ kostenlos?

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

Verketten Sie Transformationen. 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 4 von 4.

Wie lange dauert die Lektion „Funktionen kombinieren“?

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