Funktionale Programmierung in JavaScript: von A bis Z für Node.js

Funktionale Programmierung in JavaScript: von A bis Z

Funktionale Programmierung (FP) ist ein Paradigma, das Berechnungen als Auswertung mathematischer Funktionen betrachtet und die Veränderung von Zuständen und veränderlichen Daten vermeidet. Im Kontext von JavaScript (Node.js) wird FP zu einem mächtigen Werkzeug, um vorhersagbaren, testbaren und skalierbaren Code zu erstellen. In diesem Artikel behandeln wir die wichtigsten Konzepte der FP von den Grundlagen bis zu fortgeschrittenen Techniken und untermauern die Theorie mit praktischen Beispielen.

Grundlagen: Reine Funktionen und Unveränderlichkeit

Im Kern der FP stehen zwei Prinzipien: reine Funktionen und Unveränderlichkeit (Unveränderlichkeit von Daten).

Eine reine Funktion gibt für dieselben Argumente immer dasselbe Ergebnis zurück und hat keine Nebenwirkungen (sie ändert keine externen Variablen, gibt nichts auf der Konsole aus, führt keine API-Anfragen durch).

// Reine Funktionconst add = (a, b) => a + b;

// Unreine Funktion (Nebenwirkung – Änderung einer externen Variable)let counter = 0;const increment = () => counter++;

Unveränderlichkeit bedeutet, dass Daten nicht direkt geändert werden, sondern neue Kopien mit den gewünschten Änderungen erstellt werden. In JavaScript werden dazu Methoden verwendet, die neue Objekte/Arrays zurückgeben.

// Unveränderliche Aktualisierung eines Objektsconst user = { name: 'Alice', age: 30 };const updatedUser = { ...user, age: 31 }; // Neues Objekt erstellen

// Unveränderliche Aktualisierung eines Arraysconst numbers = [1, 2, 3];const newNumbers = [...numbers, 4]; // [1, 2, 3, 4]

Closures und Funktionen höherer Ordnung

Ein Closure ist eine Funktion, die sich an ihre lexikalische Umgebung "erinnert", selbst nachdem die äußere Funktion ihre Ausführung beendet hat. Dies ist die Grundlage für viele FP-Muster.

const createMultiplier = (factor) => {  // Innere Funktion – Closure  return (number) => number * factor;};

const double = createMultiplier(2);console.log(double(5)); // 10

Funktionen höherer Ordnung sind Funktionen, die andere Funktionen als Argumente akzeptieren oder zurückgeben. Klassische Beispiele sind map, filter, reduce.

const numbers = [1, 2, 3, 4, 5];

// map – transformiert jedes Elementconst doubled = numbers.map(n => n * 2); // [2, 4, 6, 8, 10]

// filter – wählt Elemente nach Bedingung ausconst even = numbers.filter(n => n % 2 === 0); // [2, 4]

// reduce – reduziert ein Array auf einen einzelnen Wertconst sum = numbers.reduce((acc, n) => acc + n, 0); // 15

Funktionskomposition und Currying

Funktionskomposition ist die Kombination mehrerer Funktionen zu einer, bei der das Ergebnis einer Funktion als Eingabe für die nächste dient. Dies ermöglicht den Aufbau komplexer Operationen aus einfachen, wiederverwendbaren Bausteinen.

const compose = (...fns) => (x) => fns.reduceRight((acc, fn) => fn(acc), x);

const trim = (str) => str.trim();const toLowerCase = (str) => str.toLowerCase();const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);

const processName = compose(capitalize, toLowerCase, trim);console.log(processName('  JOHN DOE  ')); // 'John doe'

Currying ist die Umwandlung einer Funktion mit mehreren Argumenten in eine Folge von Funktionen, die jeweils ein Argument akzeptieren. Dies vereinfacht die partielle Anwendung und Komposition.

// Normale Funktionconst multiply = (a, b, c) => a * b * c;

// Curry-Versionconst curriedMultiply = (a) => (b) => (c) => a * b * c;

console.log(curriedMultiply(2)(3)(4)); // 24

// Partielle Anwendungconst multiplyBy2 = curriedMultiply(2);const multiplyBy2And3 = multiplyBy2(3);console.log(multiplyBy2And3(5)); // 30

Praktisches Beispiel: Datenverarbeitung in Node.js