Hogyan kapcsolódik egymáshoz a változhatatlanság és a…

A változatlan (nem módosítható) objektumok és a tiszta (mellékhatások nélküli) függvények szorosan összefüggnek, mivel a változatlanság segít elérni a tisztaságot.

Tiszta függvény:

Mindig ugyanazt az eredményt adja ugyanazokra a bemeneti adatokra.
Nem változtatja meg a környezeti állapotot (nincs mellékhatása).

Ha egy függvény módosítható objektumokat vesz argumentumként és módosítja azokat, akkor nem tiszta, mert a hívása megváltoztathatja a rendszer állapotát a függvényen kívül.

A változatlan objektumok használatával:

A függvény nem módosíthatja a kapott objektumokat, mivel azok változatlanok.
Bármilyen "módosítás" új objektum létrehozásához vezet, nem a meglévő módosításához.
Ez garantálja, hogy nincsenek mellékhatások a kapott argumentumok módosításával kapcsolatban.

Példa:

<?php

// Módosítható objektum
class MutablePoint {
    public $x;
    public $y;

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

// Nem tiszta függvény (módosítja a kapott objektumot)
function moveMutablePoint(MutablePoint $point, $dx, $dy) {
    $point->x += $dx;
    $point->y += $dy;
}

$mutablePoint = new MutablePoint(0, 0);
moveMutablePoint($mutablePoint, 1, 1);
// $mutablePoint most (1, 1) - az állapot megváltozott a függvényen kívül

// Változatlan objektum
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;
    }

    // A metódus ÚJ objektumot ad vissza, nem módosítja a meglévőt
    public function move($dx, $dy): self {
        return new self($this->x + $dx, $this->y + $dy);
    }
}

// Tiszta függvény (működik változatlan objektumokkal)
function moveImmutablePoint(ImmutablePoint $point, $dx, $dy): ImmutablePoint {
    return $point->move($dx, $dy);
}

$immutablePoint = new ImmutablePoint(0, 0);
$newImmutablePoint = moveImmutablePoint($immutablePoint, 1, 1);
// $immutablePoint marad (0, 0) - az állapot nem változott a függvényen kívül
// $newImmutablePoint most (1, 1) - új objektum lett létrehozva

Az immutábilis objektumok használata az egyik módja a tiszta függvények létrehozásának, ami elősegíti a kiszámíthatóbb, tesztelhetőbb és könnyebben karbantartható kódot.

Hogyan kapcsolódik egymáshoz a változhatatlanság és a tisztaság?