Generics en PHP : pourquoi en avez-vous besoin et comment les utiliser pour les débutants

Introduction aux Generics en PHP : ce que c'est et pourquoi c'est nécessaire

Si vous commencez tout juste à apprendre PHP ou si vous écrivez déjà en PHP depuis un certain temps, vous avez sûrement rencontré des situations où une fonction ou une classe doit fonctionner avec différents types de données. Par exemple, vous créez une collection qui peut stocker à la fois des nombres, des chaînes de caractères et des objets. Sans Generics (types génériques), vous devez soit écrire des classes séparées pour chaque type, soit utiliser des types mixtes (mixed), ce qui réduit la sécurité du code.

Les Generics sont un mécanisme qui permet de créer des classes, des interfaces et des fonctions fonctionnant avec différents types de données, tout en conservant un typage strict. En PHP, le support des Generics est apparu à partir de la version 8.0, et a été considérablement amélioré dans PHP 8.1 et 8.2. Dans cet article, nous allons voir pourquoi ils sont nécessaires, comment les utiliser et quels avantages ils offrent.

Pourquoi les Generics sont-ils nécessaires en PHP ?

Le problème de l'absence de types génériques

Imaginez que vous écrivez une classe pour travailler avec une liste d'éléments. Sans Generics, vous devez utiliser le type mixed ou écrire des classes séparées pour chaque type de données :

<?php// Sans Generics — non sécuriséclass SimpleList {    private array $items = [];

    public function add($item): void {        $this->items[] = $item;    }

    public function get(int $index): mixed {        return $this->items[$index] ?? null;    }}

// Utilisation$list = new SimpleList();$list->add(42);$list->add('chaîne'); // Aucune erreur ne se produit, mais la logique est violée$value = $list->get(0); // Type mixed — l'IDE ne vous indiquera pas que c'est un int?>

Comme vous pouvez le voir, cette approche entraîne des erreurs potentielles : vous pouvez accidentellement ajouter une chaîne là où seuls des nombres sont attendus, et l'IDE ne pourra pas vous en avertir.

Avantages des Generics

• Sécurité des types : le compilateur et l'IDE vérifient la conformité des types lors de l'écriture du code.
• Réutilisabilité : une seule classe ou fonction fonctionne avec n'importe quel type de données.
• Lisibilité du code : on comprend immédiatement quels types sont attendus.
• Moins d'erreurs : les incohérences de type accidentelles sont éliminées.

Avec les Generics, la même classe de liste devient sécurisée et universelle :

<?php// Avec Generics — sécuriséclass GenericList {    private array $items = [];

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

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

// Utilisation$intList = new GenericList();$intList->add(42);// $intList->add('chaîne'); // Erreur de type !

$stringList = new GenericList();$stringList->add('Bonjour');$value = $stringList->get(0); // L'IDE sait que c'est une string?>

Comment utiliser les Generics en PHP

Syntaxe de base

Les Generics en PHP sont déclarés à l'aide de chevrons <> et de la lettre T (pour Type) — c'est le nom conventionnel pour une variable de type. Vous pouvez utiliser n'importe quel nom, mais T est la norme.

Exemple avec une classe :

<?phpclass Container {    private T $value;

    public function __construct(T $value) {        $this->value = $value;    }

    public function getValue(): T {        return $this->value;    }}

$intContainer = new Container(100);$stringContainer = new Container('Bonjour');?>

Contraintes de type

Parfois, il est nécessaire que le type du paramètre corresponde à une interface ou une classe spécifique. Pour cela, on utilise des contraintes (bounds) :

<?phpinterface Printable {    public function print(): string;}

class Document implements Printable {    public function print(): string {        return 'Document';    }