Erzählen Sie von funktionaler Programmierung und…

Funktionale Programmierung (FP) ist ein Programmierparadigma, das Berechnungen als Auswertung mathematischer Funktionen betrachtet und Zustandsänderungen sowie mutable Daten vermeidet.

Grundprinzipien:

Reine Funktionen: Eine Funktion gilt als rein, wenn:

Sie immer dasselbe Ergebnis bei denselben Argumenten liefert.
Sie keine Nebenwirkungen hat (ändert keinen globalen Zustand, führt keine Ein-/Ausgabe durch usw.).

<?php
// Reine Funktion
function add(int $a, int $b): int {
    return $a + $b;
}

// Nicht reine Funktion (hat Nebenwirkung - ändert eine globale Variable)
$count = 0;
function increment_and_get(): int {
    global $count;
    $count++;
    return $count;
}

Unveränderlichkeit der Daten: Nach ihrer Erstellung können Daten nicht mehr geändert werden. Statt das bestehende Objekt zu modifizieren, wird ein neues mit den gewünschten Änderungen erstellt.

<?php
// Beispiel für Unveränderlichkeit (in PHP ist dies kein striktes Prinzip, aber es kann umgesetzt werden)
class ImmutablePoint {
    private int $x;
    private int $y;

    public function __construct(int $x, int $y) {
        $this->x = $x;
        $this->y = $y;
    }

    public function getX(): int {
        return $this->x;
    }

    public function getY(): int {
        return $this->y;
    }

    // Statt zu ändern, gibt es ein neues Objekt zurück
    public function move(int $dx, int $dy): self {
        return new self($this->x + $dx, $this->y + $dy);
    }
}

$p1 = new ImmutablePoint(1, 2);
$p2 = $p1->move(1, 1); // $p1 bleibt bei (1, 2), $p2 wird bei (2, 3)

Funktionen als First-Class-Objekte: Funktionen können als Argumente an andere Funktionen übergeben, von Funktionen zurückgegeben und Variablen zugewiesen werden.

<?php
// Funktionen als Variablen
$greeter = function(string $name): string {
    return "Hello, " . $name;
};

echo $greeter("World"); // Ausgabe: Hello, World

// Funktionen als Argumente
function apply_transform(array $data, callable $transform): array {
    $result = [];
    foreach ($data as $item) {
        $result[] = $transform($item);
    }
    return $result;
}

$numbers = [1, 2, 3];
$doubled_numbers = apply_transform($numbers, function(int $n): int {
    return $n * 2;
}); // $doubled_numbers = [2, 4, 6]

Fehlen von Nebenwirkungen: Berechnungen beeinflussen den Zustand des Programms außerhalb ihres Geltungsbereichs nicht.
Deklarativ: Es wird auf was berechnet werden soll fokussiert, nicht auf wie.

Vorteile:

Verbesserte Testbarkeit (reine Funktionen sind leicht zu testen).
Vereinfachung der Parallelisierung (Fehlen von veränderlichem Zustand reduziert Synchronisationsprobleme).
Bessere Debugging-Möglichkeiten.
Vorhersehbareres Verhalten des Codes.

Erzählen Sie von funktionaler Programmierung und ihren Prinzipien.