Les propriétés en lecture dans PHP 8.2 ne peuvent être attribuées qu'une seule fois dans le constructeur ou lors de la déclaration et ne peuvent pas être modifiées par la suite, appliquant l'immuabilité au niveau du langage. 2. Pour atteindre une immuabilité profonde, enveloppez des types mutables comme les tableaux dans ArrayObject ou utilisez des collections immuables personnalisées telles que TagCollection qui empêchent les changements d'état directs. 3. Les meilleures pratiques incluent l'initialisation de toutes les propriétés du constructeur, d'éviter les setters, de renvoyer de nouvelles instances via des méthodes WithX (), d'utiliser les classes finales et de désactiver le clonage pour empêcher la mutation. 4. Les limitations incluent le manque de support pour les propriétés dynamiques, pas de congélation profonde d'objets ou de tableaux, et la nécessité d'une manipulation manuelle d'une mutabilité imbriquée. 5. Malgré ces gotchas, la combinaison de propriétés en lecture avec des objets de valeur et des modèles fonctionnels permet des objets immuables sécurisés, prévisibles et en filetage en utilisant uniquement des fonctionnalités PHP natifs, ce qui facilite la création de modèles de domaine robustes sans bibliothèques externes.

Dans PHP 8.2, une fonctionnalité puissante a été introduite: Readonly Properties . Cela rend beaucoup plus facile de construire des objets immuables - des objets dont l'état ne peut pas être modifié après la création. Les objets immuables sont précieux car ils sont prévisibles, en filetage et réduisent les bogues causés par des changements d'état involontaires.

Voici comment vous pouvez utiliser readonly pour créer des objets de valeur vraiment immuables dans PHP.

Que sont les propriétés en lecture?

Une propriété readonly ne peut être attribuée qu'une seule fois - soit à la déclaration ou à l'intérieur du constructeur. Après cela, il ne peut pas être modifié.

 utilisateur de classe
{
    fonction publique __construct (
        Public ReadOnly String $ id,
        Public ReadOnly String $ Email
    ) {}
}

Une fois défini, $user->email = 'new@example.com'; Je vais lancer une erreur Cannot modify readonly property .

Cela applique l'immuabilité au niveau du langage - pas besoin de s'appuyer sur les conventions ou les méthodes magiques.

Appliquer une immuabilité profonde

Utiliser readonly à lui seul ne garantit pas une immuabilité complète si votre propriété détient un type mutable comme un tableau ou un objet. Par exemple:

 blog de classe
{
    fonction publique __construct (
        Titre de la cha?ne de lecture publique en lecture
        Tags $ Array en lecture publique
    ) {}
}

$ post = nouveau blogpost ('php 8.2', ['php', 'immuable']);
$ post-> tags [] = 'readonly'; // Cela fonctionne! Le contenu du tableau peut toujours changer.

Pour éviter cela, vous devez vous défendre contre la mutation des tableaux et des objets.

? Solution: Enveloppez les tableaux dans ArrayObject ou utilisez des collections immuables

 blog de classe
{
    / **
     * @var readonly arrayObject <int, string>
     * /
    Public ReadOnly ArrayObject $ Tags;

    fonction publique __construct (
        Titre de la cha?ne de lecture publique en lecture
        Tags de l&#39;arrivée
    ) {
        $ this-> tags = new ArrayObject ($ tags);
        $ this-> tags-> setFlags (arrayObject :: array_as_props);
        $ this-> tags-> getFlags () & ~ arrayObject :: std_prop_list;
    }
}

Maintenant, vous pouvez lire $post->tags , mais la modifier (par exemple, $post->tags[] = 'hack' ) échouera parce que la propriété elle-même est en lecture - vous ne pouvez pas la réaffecter, et si vous exposez des méthodes pour manipuler l'état interne, vous les contr?lez explicitement.

Alternativement, envisagez d'utiliser des objets de valeur pour les collections :

 / **
 * @Implements \ iteratoraggregate <string>
 * /
Class TagCollection implémente \ iteratoraggregate
{
    Tags de table privée $;

    fonction publique __construct (array $ tags) {
        $ this-> tags = array_values (array_unique ($ tags));
    }

    fonction publique getIterator (): \ Traversable
    {
        return new \ arrayiterator ($ this-> tags);
    }

    fonction publique avec Aadded (String $ tag): soi
    {
        return new self ([... $ this-> tags, $ tag]);
    }
}

blog de classe
{
    fonction publique __construct (
        Titre de la cha?ne de lecture publique en lecture
        Public ReadOnly TagCollection $ Tags
    ) {}
}

Maintenant, l'immutabilité est conservée: vous ne pouvez pas modifier $post->tags , et même si vous l'itérez, les modifications nécessitent la création d'une nouvelle instance.

Meilleures pratiques pour les objets immuables

Pour construire des objets immuables robustes en PHP:

• ? Utilisez readonly sur toutes les propriétés
• ? Initialisez tout dans le constructeur
• ? évitez les réseaux publics ou les méthodes de mutator
• ? Renvoie de nouvelles instances au lieu de modifier l'état
• ? Utilisez des classes finales pour éviter les remplacements involontaires
• ? Envisagez d'utiliser __clone() pour éviter une mutation accidentelle via le clonage

 utilisateur de classe finale
{
    fonction publique __construct (
        Public ReadOnly String $ id,
        Public ReadOnly String $ Name,
        Public ReadOnly String $ Email
    ) {}

    // Au lieu de setEmail (), renvoyez une nouvelle instance
    Fonction publique WithEmail (String $ e-mail): Self
    {
        Renvoie un nouveau self ($ this-> id, $ this-> name, $ e-mail);
    }

    // Empêcher le clonage (facultatif)
    fonction publique __clone ()
    {
        lancer un nouveau \ badmethodcallexception (?le clonage est désactivé pour l'objet immuable.?);
    }
}

Usage:

 $ user = New User ('123', 'Alice', 'Alice@example.com');
$ updated = $ user-> withemail ('alice@new.com '); // Nouvelle instance
// $ l'utilisateur reste inchangé

Limitations et gotchas

• readonly ne fonctionne que sur les propriétés de classe - pas les propriétés dynamiques
• Vous ne pouvez pas affecter à une propriété en lecture à l'extérieur du constructeur, même à partir de la classe
• Les objets et les tableaux affectés aux accessoires en lecture ne sont pas profondément gelés - vous devez gérer cela vous-même
• PHP n'a pas de tableaux immuables intégrés, vous aurez donc besoin d'emballages ou de logique personnalisée

Résumé

Avec readonly dans PHP 8.2, la construction d'objets immuables est désormais pratique et s?re. Combinez les propriétés readonly avec la copie défensive, les objets de valeur et les méthodes de style fonctionnel ( withX() au lieu de setX() ) pour créer des modèles de domaine propre et prévisible.

Vous n'avez pas besoin d'un cadre ou d'une bibliothèque - juste une bonne conception et des fonctionnalités intégrées de PHP.

Fondamentalement: déclarez-le une fois, restez en sécurité .

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!