Generics en PHP : pourquoi les utiliser et comment les utiliser avec des exemples

Generics en PHP : pourquoi en avez-vous besoin et comment les utiliser

Le développement moderne en PHP nécessite non seulement de la vitesse, mais aussi de la fiabilité du code. L'un des outils qui permet d'atteindre cet objectif est les Generics (types génériques). Bien que PHP soit un langage à typage dynamique, avec la sortie de PHP 7.0 et plus, et surtout avec PHP 8.0, le typage statique est devenu accessible et recherché. Les Generics permettent d'écrire des structures de données plus flexibles, réutilisables et sûres, telles que des collections, des piles, des files d'attente et des repositories, sans perte d'informations sur les types.

Dans cet article, nous allons détailler ce que sont les Generics en PHP, pourquoi ils sont nécessaires, comment les utiliser correctement en pratique, et examiner des exemples de code concrets.

Que sont les Generics et pourquoi en avez-vous besoin ?

Generics (types génériques) est un mécanisme qui permet de paramétrer des classes, des interfaces, des traits et des fonctions avec un type de données. Au lieu d'écrire une implémentation séparée pour chaque type (par exemple, IntegerList, StringList, UserList), vous créez une classe universelle List<T>, où T est un placeholder (substitut) pour un type spécifique qui sera passé lors de l'utilisation.

Pourquoi est-ce nécessaire ?

• Sécurité des types : Les IDE et les analyseurs statiques (Psalm, PHPStan) peuvent vérifier que seuls des éléments d'un même type entrent dans la collection, évitant ainsi les erreurs au stade du développement.
• Réduction de la duplication de code : Vous n'avez pas besoin d'écrire la même classe pour différents types de données.
• Amélioration de la lisibilité : Le code devient auto-documenté — on voit immédiatement quels types de données sont attendus.
• Augmentation des performances : Bien que PHP lui-même n'utilise pas les Generics au niveau de la machine virtuelle (comme Java ou C#), les analyseurs statiques aident à trouver les erreurs potentielles avant l'exécution du code.

Comment utiliser les Generics en PHP ? Syntaxe et exemples

À partir de PHP 8.0, la prise en charge des Generics a été introduite au niveau des annotations (docblock) et partiellement au niveau du code (pour les variadic arguments). Une prise en charge complète au niveau de la syntaxe est attendue dans les versions futures, mais il est déjà possible d'utiliser efficacement les Generics avec PHPDoc et les analyseurs statiques.

1. Syntaxe de base avec PHPDoc

La méthode la plus courante consiste à utiliser les annotations @template et @param/@return avec l'indication du type générique.

<?php

/** * @template T */class Collection {    /** @var array<T> */    private array $items;

    /**     * @param T $item     */    public function add($item): void {        $this->items[] = $item;    }

    /**     * @return T|null     */    public function get(int $index) {        return $this->items[$index] ?? null;    }}

// Exemple d'utilisation$intCollection = new Collection();$intCollection->add(42);// $intCollection->add('string'); // Erreur de l'analyseur statique

$userCollection = new Collection();$userCollection->add(new User());// $userCollection->add(123); // Erreur?>

Dans cet exemple, @template T déclare un type générique. @param T $item et @return T|null indiquent à l'analyseur que le type des éléments doit être cohérent.

2. Contraintes de type (bounded generics)

Vous pouvez limiter les types pouvant être utilisés comme paramètre. Cela se fait avec @extends ou @implements.

<?php

/** * @template T of \\Stringable */class StringableCollection {    /** @var array<T> */    private array $items;

    /**     * @param T $item     */    public function add($item): void {        $this->it