Promotion des propriétés du constructeur est une fonctionnalité introduite dans PHP 8 qui simplifie la déclaration et l'initialisation des propriétés au sein d'une classe. Avant PHP 8, vous deviez déclarer explicitement les propriétés de classe, puis les initialiser dans le constructeur. Avec cette fonctionnalité, vous pouvez déclarer et initialiser des propriétés directement dans la liste des paramètres du constructeur, réduisant ainsi le code passe-partout.

Syntaxe traditionnelle (avant PHP 8)

class Product {
    private string $name;
    private float $price;

    public function __construct(string $name, float $price) {
        $this->name = $name;
        $this->price = $price;
    }
}

Syntaxe de promotion de propriété de constructeur (PHP 8)

class Product {
    public function __construct(
        private string $name,
        private float $price
    ) {}
}

Avantages

1. Réduit le code passe-partout?:

   • élimine le besoin de déclarer des propriétés en dehors du constructeur et de les initialiser manuellement.

2. Améliore la lisibilité?:

   • Rend le code plus concis et plus facile à comprendre, en particulier dans les classes comportant de nombreuses propriétés.

3. Prend en charge l'immuabilité?:

   • Les propriétés peuvent être marquées en lecture seule (introduites dans PHP 8.1) pour empêcher les modifications après l'initialisation.

Remarques

1. Modificateurs de visibilité?:

   • Les propriétés promues doivent inclure un modificateur de visibilité (privé, protégé ou public).

2. Valeurs par défaut?:

   • Vous ne pouvez pas définir de valeurs par défaut directement pour les propriétés promues, mais vous pouvez utiliser les valeurs d'argument par défaut dans le constructeur.

   class Product {
      public function __construct(
          private string $name = 'Unnamed',
          private float $price = 0.0
      ) {}
   }
   

3. Mélanger les propriétés promues et non promues?:

   • Vous pouvez combiner des propriétés traditionnelles et des propriétés promues dans une même classe.

   class Product {
      private string $category;
   
      public function __construct(
          private string $name,
          private float $price
      ) {
          $this->category = 'General';
      }
   }
   

Cas d'utilisation

Promotion des propriétés du constructeur est particulièrement utile pour les classes simples comme les DTO (Data Transfer Objects), dont l'objectif principal est de stocker des données.

class CustomerDTO {
    public function __construct(
        public string $name,
        public string $email,
        public ?string $phone = null
    ) {}
}

Conclusion

Constructor Property Promotion est une fonctionnalité puissante de PHP 8 qui améliore la productivité et réduit la complexité du code. Il est idéal pour les classes avec plusieurs propriétés où une initialisation concise et claire est souhaitée.

Intégration d'attributs

Dans PHP 8, les attributs (également appelés annotations) peuvent être combinés de manière transparente avec la Promotion des propriétés du constructeur, ce qui donne un code plus propre et plus expressif, en particulier dans les scénarios où les métadonnées doivent être associées à des propriétés.

Intégration avec Promotion Propriété Constructeur

Avec Constructor Property Promotion, les propriétés sont définies directement dans le constructeur. Vous pouvez utiliser des attributs pour décorer ces propriétés et ajouter des informations contextuelles sans avoir besoin de déclarer les propriétés séparément.

Exemple pratique

Supposons que vous travailliez sur un DTO (Data Transfer Object) et que vous souhaitiez mapper les propriétés aux colonnes de la base de données

Sans promotion immobilière constructeur

class Product {
    private string $name;
    private float $price;

    public function __construct(string $name, float $price) {
        $this->name = $name;
        $this->price = $price;
    }
}

Avec Promotion Propriété Constructeur

class Product {
    public function __construct(
        private string $name,
        private float $price
    ) {}
}

Avantages de l'intégration

1. Code passe-partout réduit?:

   • Les propriétés promues éliminent les déclarations en double et les attributs peuvent être appliqués directement aux propriétés du constructeur.

2. Code plus propre et plus lisible?:

   • L'intégration combine l'initialisation, les métadonnées et la visibilité en un seul endroit.

3. Flexibilité avec réflexion?:

   • Vous pouvez utiliser l'API Reflection de PHP pour accéder et traiter les attributs appliqués aux propriétés promues.

Accès aux attributs avec réflexion

class Product {
   public function __construct(
       private string $name = 'Unnamed',
       private float $price = 0.0
   ) {}
}

Explication du Code

1. Définition de l'attribut de colonne?:

   • Le décorateur #[Attribute] indique que la classe Column est un attribut.
   • La classe d'attribut accepte un seul nom de paramètre, qui est utilisé pour associer une propriété à une colonne de base de données.

2. Ajout d'attributs aux paramètres du constructeur?:

   • Des attributs comme #[Column('user_id')] et #[Column('username')] sont ajoutés aux paramètres du constructeur id et name.

3. Utiliser la réflexion?:

   • L'objet ReflectionClass est créé pour la classe User, nous permettant d'inspecter ses propriétés et ses méthodes.

4. Accès au constructeur?:

   • getConstructor() récupère le constructeur de la classe User.

5. Itération sur les paramètres?:

   • getParameters() récupère tous les paramètres du constructeur.

6. Récupération des attributs?:

   • getAttributes(Column::class) récupère tous les attributs de type Column appliqués à un paramètre.

7. Instanciation de l'attribut?:

   • newInstance() crée une instance de l'attribut Column, donnant accès à sa propriété name.

8. Impression des métadonnées?:

   • Envoie le nom du paramètre (par exemple, id) et le nom de la colonne associée (par exemple, user_id) sur la console.

Sortie?:

class Product {
   private string $category;

   public function __construct(
       private string $name,
       private float $price
   ) {
       $this->category = 'General';
   }
}

Cas d'utilisation courants

1. Mappage de base de données?:

   • Utiliser des attributs tels que #[Column] pour spécifier les colonnes de la base de données.

2. Validation des données?:

   • Appliquer des validations directement aux propriétés, telles que #[NotNull] ou #[MaxLength(255)].

3. Sérialisation/Désérialisation?:

   • Mappage des propriétés avec des champs JSON, par exemple #[JsonField('user_name')].

Conclusion

L'intégration de Constructor Property Promotion avec Attributs fournit un moyen puissant et concis de structurer les classes en PHP. Ceci est particulièrement utile dans les systèmes qui s'appuient sur des métadonnées, telles que l'ORM, la validation ou la sérialisation, rendant le code plus expressif et organisé.

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!