map, filter, reduce
Erstellen Sie Higher-Order-Hilfsfunktionen.
map, filter, reduce 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.
Die drei Grundwerkzeuge
Map, Filter und Reduce sind die wichtigsten Werkzeuge für die funktionale Verarbeitung von Listen. Jedes nimmt eine Liste und eine Funktion entgegen und gibt ein Ergebnis zurück, ohne dass Sie die Schleife selbst schreiben müssen.
Lua liefert diese Werkzeuge nicht standardmäßig mit, aber sie sind schnell geschrieben und zeigen, wie Funktionen höherer Ordnung funktionieren.
Map: Jedes Element transformieren
Map wendet eine Funktion auf jedes Element an und sammelt die Ergebnisse in einer neuen Liste. Die ursprüngliche Liste bleibt unverändert.
Die übergebene Funktion bestimmt die Transformation. Daher kann ein einziges map das Verdoppeln, Quadrieren oder jede andere Änderung pro Element übernehmen.
local function map(t, f)
local out = {}
for i, v in ipairs(t) do
out[i] = f(v)
end
return out
end
local r = map({1, 2, 3}, function(x) return x * x end)
print(table.concat(r, ", "))Map erhält die Länge
Map gibt immer eine Liste mit genauso vielen Elementen wie die Eingabeliste zurück. Jedes Element wird genau einem Ausgabeelement zugeordnet.
Wenn Sie Elemente entfernen müssen, ist das die Aufgabe von Filter, nicht von Map.
local function map(t, f)
local out = {}
for i, v in ipairs(t) do out[i] = f(v) end
return out
end
local names = {"ada", "lin", "sam"}
local caps = map(names, string.upper)
print(table.concat(caps, " "))
print(#caps)Filter: Einige Elemente behalten
Filter behält nur die Elemente, für die ein Prädikat true zurückgibt. Ein Prädikat ist eine Funktion, die einen booleschen Wert zurückgibt.
Das Ergebnis ist eine neue Liste, die kürzer als die ursprüngliche sein kann, aber niemals länger ist.
local function filter(t, pred)
local out = {}
for _, v in ipairs(t) do
if pred(v) then out[#out + 1] = v end
end
return out
end
local evens = filter({1,2,3,4,5,6}, function(x) return x % 2 == 0 end)
print(table.concat(evens, ", "))Filter bewahrt die Reihenfolge
Filter durchläuft die Liste in ihrer Reihenfolge und fügt jedes behaltene Element an. Dadurch bleiben die überlebenden Elemente in ihrer ursprünglichen Reihenfolge.
Wenn Sie #out + 1 als Index verwenden, bleibt das Ergebnis ein lückenfreies Array, das Lua als korrekte Sequenz behandelt.
local function filter(t, pred)
local out = {}
for _, v in ipairs(t) do
if pred(v) then out[#out + 1] = v end
end
return out
end
local long = filter({"hi", "hello", "yo", "howdy"},
function(s) return #s > 2 end)
print(table.concat(long, ", "))Reduce: Zu einem Wert zusammenfassen
Reduce, auch Fold genannt, fasst eine Liste zu einem einzelnen Wert zusammen. Dabei führt die Funktion einen Akkumulator und kombiniert ihn mithilfe Ihrer Funktion mit jedem Element.
Sie geben einen Startwert und eine kombinierende Funktion vor. Reduce führt den Akkumulator dann durch jedes Element.
local function reduce(t, f, acc)
for _, v in ipairs(t) do
acc = f(acc, v)
end
return acc
end
local sum = reduce({1,2,3,4}, function(a, x) return a + x end, 0)
print(sum)Reduce ist flexibel
Durch Ändern der kombinierenden Funktion und des Startwerts kann Reduce Werte addieren, multiplizieren, ein Maximum finden oder eine Zeichenkette aufbauen.
Hier beginnt der Akkumulator bei 1 und wird multipliziert, wodurch ein Produkt nach Art einer Fakultät entsteht.
local function reduce(t, f, acc)
for _, v in ipairs(t) do acc = f(acc, v) end
return acc
end
local product = reduce({1,2,3,4,5}, function(a, x) return a * x end, 1)
print(product)Mit Reduce ein Maximum finden
Reduce ist nicht auf arithmetische Berechnungen beschränkt. Die kombinierende Funktion kann Werte vergleichen und bei jedem Schritt den größeren behalten.
Wenn Sie den Akkumulator mit dem ersten Element oder einer sehr kleinen Zahl starten, kann Reduce auf übersichtliche Weise ein Maximum finden.
local function reduce(t, f, acc)
for _, v in ipairs(t) do acc = f(acc, v) end
return acc
end
local max = reduce({3, 8, 2, 11, 6},
function(a, x) if x > a then return x else return a end end, -math.huge)
print(max)Die drei Werkzeuge verketten
Die eigentliche Stärke zeigt sich, wenn Sie die drei Werkzeuge verketten. Filter schränkt die Daten ein, Map transformiert sie und Reduce fasst sie zusammen.
Jede Stufe ist ein kleiner, klarer Schritt. Gemeinsam ersetzen sie eine unübersichtliche manuelle Schleife.
local function filter(t, p) local o={} for _,v in ipairs(t) do if p(v) then o[#o+1]=v end end return o end
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function reduce(t, f, a) for _,v in ipairs(t) do a=f(a,v) end return a end
local nums = {1,2,3,4,5,6}
local r = reduce(map(filter(nums, function(x) return x%2==0 end),
function(x) return x*x end), function(a,x) return a+x end, 0)
print(r)Die ursprünglichen Listen bleiben erhalten
Map und Filter erstellen immer neue Tabellen und verändern die Eingabe niemals. Dadurch bleiben Pipelines vorhersehbar: Die ursprünglichen Daten sind nach jeder Stufe weiterhin verfügbar.
Auch Reduce lässt die Liste unverändert und gibt nur das zusammengefasste Ergebnis zurück.
Für jede Liste geeignet
Da die Funktion ein Parameter ist, funktionieren diese Werkzeuge mit beliebigen Daten. Dasselbe map kann Zeichenketten in Großbuchstaben umwandeln, Preise skalieren oder Datensätze formatieren.
Die Schleife einmal zu schreiben und unterschiedliche Funktionen zu übergeben, ist genau der Grund, warum erstklassige Funktionen so nützlich sind.
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local prices = {10, 20, 30}
local withTax = map(prices, function(p) return p * 1.18 end)
print(table.concat(withTax, ", "))Schnelltest
Überlegen Sie, wie sich diese Operationen auf die Länge einer Liste auswirken.
Zusammenfassung
Map transformiert jedes Element und erhält die Länge, Filter behält die Elemente, die ein Prädikat erfüllen, und Reduce faltet eine Liste mithilfe eines Akkumulators zu einem einzelnen Wert zusammen.
Durch das Verketten von Filter, Map und Reduce entstehen übersichtliche Datenpipelines ohne manuelle Schleifen, und die ursprünglichen Tabellen bleiben unverändert.
Häufig gestellte Fragen
Ist die Lektion „map, filter, reduce“ kostenlos?
Ja — der vollständige Text von „map, filter, reduce“ 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 „map, filter, reduce“?
Erstellen Sie Higher-Order-Hilfsfunktionen. 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 „map, filter, reduce“?
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
- Funktionen als Werte
- map, filter, reduce
- Partielle Anwendung
- Funktionen kombinieren