Readonly -Eigenschaften in PHP 8.2 k?nnen nur einmal im Konstruktor oder bei der Deklaration zugewiesen werden und k?nnen danach nicht ge?ndert werden, was die Unver?nderlichkeit auf Sprachebene durchsetzte. 2. Um eine tiefe Unver?nderlichkeit zu erzielen, wickeln Sie ver?nderliche Typen wie Arrays in ArrayObject oder verwenden Sie benutzerdefinierte unver?nderliche Sammlungen wie TagCollection, die ?nderungen der direkten Zustands?nderungen verhindern. 3. Die Best Practices umfassen die Initialisierung aller Eigenschaften im Konstruktor, die Vermeidung von Setzen, die Rückgabe neuer Instanzen über Withx () -Methoden, die endgültigen Klassen und das Deaktivieren der Klonierung zur Verhinderung von Mutationen. 4. Einschr?nkungen umfassen mangelnde Unterstützung für dynamische Eigenschaften, kein tiefes Einfrieren von Objekten oder Arrays sowie die Bedürfnisse des manuellen Umgangs mit verschachtelten Ver?nderlichkeit. 5. Trotz dieser GOTCHAS erm?glicht die Kombination von Readonly-Eigenschaften mit Wertobjekten und Funktionsmustern sichere, vorhersehbare und thread-sichere unver?nderliche Objekte nur mit nativen PHP-Funktionen, wodurch es einfacher ist, robuste Dom?nenmodelle ohne externe Bibliotheken zu erstellen.

In PHP 8.2 wurde ein leistungsstarkes Merkmal vorgestellt: Readonly -Eigenschaften . Dies erleichtert es viel einfacher, unver?nderliche Objekte aufzubauen - Objekte, deren Zustand nach der Erstellung nicht ge?ndert werden kann. Unver?nderliche Objekte sind wertvoll, da sie vorhersehbar, fadensicher sind und Fehler reduzieren, die durch unbeabsichtigte Zustands?nderungen verursacht werden.

So k?nnen Sie readonly verwenden, um in PHP wirklich unver?nderliche Wertobjekte zu erstellen.

Was sind Readonly -Eigenschaften?

Eine readonly -Eigenschaft kann nur einmal zugewiesen werden - entweder bei der Erkl?rung oder im Konstruktor. Danach kann es nicht ge?ndert werden.

 Klassenbenutzer
{
    ?ffentliche Funktion __construct (
        public readonly String $ id,
        ?ffentliche readonly String $ E -Mail
    ) {}
}

Sobald $user->email = 'new@example.com'; Werfen Sie einen Cannot modify readonly property .

Dies erzwingt die Unver?nderlichkeit auf Sprachebene - keine Notwendigkeit, sich auf Konventionen oder magische Methoden zu verlassen.

Durchsetzung einer tiefen Unver?nderlichkeit

Die Verwendung readonly allein garantiert keine vollst?ndige Unver?nderlichkeit, wenn Ihre Eigenschaft einen ver?nderlichen Typ wie ein Array oder Objekt enth?lt. Zum Beispiel:

 Klassenblogpost
{
    ?ffentliche Funktion __construct (
        public readonly String $ title,
        ?ffentliche Readonly Array $ tags
    ) {}
}

$ post = neuer Blogpost ('Php 8.2', ['php', 'unver?nderlich']);
$ post-> tags [] = 'readonly'; // das funktioniert! Array -Inhalte k?nnen sich noch ?ndern.

Um dies zu verhindern, müssen Sie sich gegen die Mutation von Arrays und Objekten verteidigen .

? L?sung: Wickeln Arrays in ArrayObject oder verwenden Sie unver?nderliche Sammlungen

 Klassenblogpost
{
    /**
     * @var readonly arrayObject <int, String>
     */
    public readonly arrayObject $ tags;

    ?ffentliche Funktion __construct (
        public readonly String $ title,
        Array $ tags
    ) {
        $ this-> tags = new ArrayObject ($ tags);
        $ this-> tags-> setflags (arrayObject :: array_as_props);
        $ this-> tags-> getflags () & ~ ArrayObject :: std_prop_list;
    }
}

Jetzt k?nnen Sie $post->tags lesen, aber das ?ndern von (z. B. $post->tags[] = 'hack' ) wird fehlschlagen, da die Eigenschaft selbst readonly ist-Sie k?nnen es nicht neu zuweisen. Wenn Sie Methoden zur Manipulation des internen Zustands aussetzen, steuern Sie sie explizit.

Alternativ sollten Sie Wertobjekte für Sammlungen verwenden:

 /**
 * @Implements \ iteratorAggregate <string>
 */
Klasse tagcollection implementiert \ iteratoraggregate
{
    private Array $ tags;

    ?ffentliche Funktion __construct (Array $ tags) {
        $ this-> tags = array_values (array_unique ($ tags));
    }

    ?ffentliche Funktion getiterator (): \ traversable
    {
        Neue \ arrayiterator zurückgeben ($ this-> Tags);
    }

    ?ffentliche Funktion mit verabreichtem (String $ Tag): Selbst
    {
        Neues Selbst zurückgeben ([... $ this-> Tags, $ tag]);
    }
}

Klassenblogpost
{
    ?ffentliche Funktion __construct (
        public readonly String $ title,
        public readonly tagcollection $ tags
    ) {}
}

Jetzt ist die Unver?nderlichkeit erhalten: Sie k?nnen $post->tags nicht ?ndern, und selbst wenn Sie es iterieren, müssen ?nderungen eine neue Instanz erstellen.

Best Practices für unver?nderliche Objekte

Um robuste unver?nderliche Objekte in PHP zu erstellen:

• ? Verwenden Sie auf allen Eigenschaften readonly
• ? Initialisieren Sie alles im Konstruktor
• ? Vermeiden Sie ?ffentliche Setzer oder Mutatormethoden
• ? Neue Instanzen zurückgeben, anstatt den Zustand zu ?ndern
• ? Verwenden Sie endgültige Klassen, um unbeabsichtigte überschüsse zu verhindern
• ? Erw?gen Sie, __clone() zu verwenden, um eine versehentliche Mutation durch Klonen zu verhindern

 Final Class User
{
    ?ffentliche Funktion __construct (
        public readonly String $ id,
        public readonly String $ Name,
        ?ffentliche readonly String $ E -Mail
    ) {}

    // anstelle von setemail () geben Sie eine neue Instanz zurück
    ?ffentliche Funktion mit email (String $ E -Mail): Selbst
    {
        Neues Selbst zurückgeben ($ this-> id, $ this-> name, $ mail);
    }

    // Klonen verhindern (optional)
    ?ffentliche Funktion __clone ()
    {
        Neue \ badMethodcallexception werfen ('Klonen ist für unver?nderliches Objekt deaktiviert.');
    }
}

Verwendung:

 $ user = new user ('123', 'alice', 'alice@example.com');
$ updated = $ user-> Withemail ('alice@new.com '); // Neue Instanz
// $ user bleibt unver?ndert

Einschr?nkungen und Gotchas

• readonly funktioniert nur an Klasseneigenschaften - nicht an dynamischen Eigenschaften
• Sie k?nnen einer Readonly -Eigenschaft au?erhalb des Konstruktors nicht zuweisen, auch nicht aus der Klasse
• Objekte und Arrays, die Readonly -Requisiten zugewiesen sind, sind nicht tief eingefroren - Sie müssen das selbst bew?ltigen
• PHP hat keine integrierten unver?nderlichen Arrays, daher ben?tigen Sie Wrapper oder benutzerdefinierte Logik

Zusammenfassung

Mit readonly in PHP 8.2 ist es praktisch und sicher, unver?nderliche Objekte zu bauen. Kombinieren Sie readonly -Eigenschaften mit defensivem Kopieren, Wertobjekten und Methoden im funktionalen Stil ( withX() anstelle von setX() ), um saubere, vorhersehbare Dom?nenmodelle zu erstellen.

Sie ben?tigen kein Framework oder keine Bibliothek-nur ein gutes Design und die integrierten Funktionen von PHP.

Grunds?tzlich: Deklarieren Sie es einmal, halten Sie es sicher .

Das obige ist der detaillierte Inhalt vonAufbau unver?nderlicher Objekte in PHP mit Readonly -Eigenschaften. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!