Funktionale Programmierung in PHP: Grundlagen und Beispiele

Funktionale Programmierung in PHP: Von der Theorie zur Praxis

PHP wird traditionell mit imperativen und objektorientierten Ansätzen assoziiert, jedoch bietet die moderne Sprache leistungsstarke Werkzeuge für die funktionale Programmierung (FP). In diesem Artikel werden wir erläutern, wie man FP-Prinzipien in PHP anwendet: von anonymen Funktionen bis hin zu Currying und Immutability. Sie erfahren, wie Sie Code vorhersagbarer, testbarer und prägnanter gestalten können.

1. Grundlagen: Anonyme Funktionen und Closures

Anonyme Funktionen (Lambdas) sind der Eckpfeiler der FP in PHP. Sie ermöglichen es, Verhalten als Daten zu übergeben.

<?php// Einfache anonyme Funktion$greet = function($name) {    return "Hallo, $name!";};echo $greet('Welt'); // Hallo, Welt!

// Verwendung mit array_map$numbers = [1, 2, 3, 4, 5];$squared = array_map(function($n) {    return $n * $n;}, $numbers);print_r($squared); // [1, 4, 9, 16, 25]?>

Closures sind anonyme Funktionen, die Variablen aus dem äußeren Gültigkeitsbereich mit dem Schlüsselwort use einfangen:

<?php$factor = 3;$multiply = function($n) use ($factor) {    return $n * $factor;};echo $multiply(5); // 15

// Closure mit veränderlicher Variable (per Referenz)$counter = 0;$increment = function() use (&$counter) {    $counter++;};$increment();echo $counter; // 1?>

Closures sind unverzichtbar bei der Erstellung von Callback-Funktionen und Fabriken.

2. Funktionen höherer Ordnung: array_map, array_filter, array_reduce

PHP enthält klassische Funktionen höherer Ordnung, die andere Funktionen als Argumente akzeptieren:

• array_map — transformiert jedes Element eines Arrays;
• array_filter — filtert Elemente basierend auf einer Bedingung;
• array_reduce — reduziert ein Array auf einen einzelnen Wert.

<?php$data = [1, 2, 3, 4, 5, 6];

// Filtern gerader Zahlen$even = array_filter($data, function($n) {    return $n % 2 === 0;}); // [2, 4, 6]

// Verdoppeln jedes Elements$doubled = array_map(function($n) {    return $n * 2;}, $even); // [4, 8, 12]

// Summe aller Werte$sum = array_reduce($doubled, function($carry, $n) {    return $carry + $n;}, 0); // 24?>

Beachten Sie: array_filter behält die Schlüssel. Wenn eine Neuindizierung erforderlich ist, verwenden Sie array_values().

3. Immutability und Datenverarbeitung

Funktionale Programmierung fördert Immutability – die Unveränderlichkeit von Daten. Anstatt vorhandene Objekte zu modifizieren, werden neue erstellt.

<?php// Imperativer Ansatz (Mutation)$user = ['name' => 'Ivan', 'age' => 25];$user['age'] = 26; // ändert das ursprüngliche Array

// Funktionaler Ansatz (immutable)$user = ['name' => 'Ivan', 'age' => 25];$updatedUser = array_merge($user, ['age' => 26]); // neues Array?>

Für die Arbeit mit Arrays verwenden Sie array_merge, array_slice und den Spread-Operator (PHP 7.4+):

<?php$original = [1, 2, 3];$new = [...$original, 4]; // [1, 2, 3, 4] — das Original bleibt unverändert?>

Immutability vereinfacht das Debugging und macht den Code threadsicher.

4. Currying und partielle Anwendung

Currying ist die Umwandlung einer Funktion mit mehreren Argumenten in eine Folge von Funktionen mit jeweils einem Argument. Partielle Anwendung ist das Fixieren eines Teils der Argumente.

PHP hat kein eingebautes Currying, aber es lässt sich leicht implementieren:

<?php// Curry-Funktion für Additionfunction curryAdd($a) {    return function($b) use ($a) {        return function($c) use ($a, $b) {            return $a + $b + $c;        };    };}

$add5 = curryAdd(5);```