Wie hängen Unveränderlichkeit und Reinheit zusammen…

Unveränderlichkeit (nicht änderbare Objekte) und Reinheit (Funktionen ohne Nebenwirkungen) sind eng miteinander verbunden, da Unveränderlichkeit dazu beiträgt, Reinheit zu erreichen.

Reine Funktion:

Gibt immer dasselbe Ergebnis für dieselben Eingabedaten zurück.
Ändert den Zustand außerhalb ihres Geltungsbereichs nicht (hat keine Nebenwirkungen).

Wenn eine Funktion änderbare Objekte als Argumente nimmt und sie modifiziert, ist sie nicht rein, da ihr Aufruf den Zustand des Systems außerhalb der Funktion ändern kann.

Durch die Verwendung von unveränderlichen Objekten:

Kann die Funktion die übergebenen Objekte nicht ändern, da sie unveränderlich sind.
Jede "Änderung" führt zur Erstellung eines neuen Objekts, nicht zur Modifikation des bestehenden.
Dies garantiert das Fehlen von Nebenwirkungen im Zusammenhang mit der Änderung der übergebenen Argumente.

Beispiel:

<?php

// Änderbares Objekt
class MutablePoint {
    public $x;
    public $y;

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

// Nicht reine Funktion (ändert das übergebene Objekt)
function moveMutablePoint(MutablePoint $point, $dx, $dy) {
    $point->x += $dx;
    $point->y += $dy;
}

$mutablePoint = new MutablePoint(0, 0);
moveMutablePoint($mutablePoint, 1, 1);
// $mutablePoint ist jetzt (1, 1) - der Zustand hat sich außerhalb der Funktion geändert

// Unveränderliches Objekt
final class ImmutablePoint {
    private $x;
    private $y;

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

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

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

    // Die Methode gibt EIN NEUES Objekt zurück, ändert nicht das aktuelle
    public function move($dx, $dy): self {
        return new self($this->x + $dx, $this->y + $dy);
    }
}

// Reine Funktion (arbeitet mit unveränderlichen Objekten)
function moveImmutablePoint(ImmutablePoint $point, $dx, $dy): ImmutablePoint {
    return $point->move($dx, $dy);
}

$immutablePoint = new ImmutablePoint(0, 0);
$newImmutablePoint = moveImmutablePoint($immutablePoint, 1, 1);
// $immutablePoint bleibt bei (0, 0) - der Zustand hat sich außerhalb der Funktion nicht geändert
// $newImmutablePoint ist jetzt (1, 1) - es wurde ein neues Objekt erstellt

Die Verwendung von unveränderlichen Objekten ist somit eine Möglichkeit, reine Funktionen zu erstellen, was zu vorhersehbarerem, testbarem und wartbarem Code führt.

Wie hängen Unveränderlichkeit und Reinheit zusammen?