Les enums (énumérations, PHP 8.1+) définissent un type avec un ensemble fixe de valeurs nommées — une fonctionnalité longtemps attendue qui offre la sécurité des types pour des ensembles d'options contraints (statuts, rôles, types) bien mieux que l'ancienne approche utilisant des constantes de classe ou des chaînes magiques.
{
Active;
Inactive;
Pending;
}
= ::;
{}
(::);
();
Un enum pur définit des cas nommés. Utilisé comme indication de type, il garantit que seules les valeurs valides sont acceptées — éliminant les bugs dus au passage de chaînes/entiers arbitraires.
enum Status: string { // "backed" by string values
case Active = 'active';
case Inactive = 'inactive';
case Pending = 'pending';
}
Status::Active->value; // 'active' — the backing value
Status::from('active'); // Status::Active — convert FROM the value
Status::tryFrom('bad'); // null if invalid (instead of throwing)
Status::cases(); // [Active, Inactive, Pending] — all cases
Les enums avec support associent chaque cas à une valeur scalaire (chaîne ou entier) — utile pour stocker dans une base de données ou sérialiser, avec from()/tryFrom() pour convertir à partir de valeurs et cases() pour lister tous les cas.
enum Status: string {
case Active = 'active';
case Inactive = 'inactive';
public function label(): string { // methods on the enum
return match($this) {
Status::Active => 'Active User',
Status::Inactive => 'Inactive User',
};
}
public function isActive(): bool {
return $this === Status::Active;
}
}
Status::Active->label(); // "Active User"
Les enums peuvent avoir des méthodes (et implémenter des interfaces), ce qui vous permet d'attacher du comportement à chaque cas — les rendant des outils puissants pour la modélisation de domaine.
// ❌ before enums — class constants or magic strings: no type safety, typo-prone
class Status { const ACTIVE = 'active'; const INACTIVE = 'inactive'; }
function setStatus(string $s) {} // accepts ANY string — "actve" typo compiles fine
Les enums (PHP 8.1+) sont une fonctionnalité importante et longtemps attendue qui apporte la véritable sécurité des types aux ensembles de valeurs contraintes — et les comprendre devient de plus en plus essentiel à mesure que les bases de code PHP modernes les adoptent.
Avant les enums, les développeurs représentaient des ensembles d'options fixes (statuts, rôles, types, états) avec des constantes de classe ou des chaînes/entiers bruts, ce qui offrait aucune sécurité de type (n'importe quelle chaîne était acceptée, donc les fautes de frappe comme "actve" compilaient sans problème et causaient des bugs à l'exécution) et aucun moyen de contraindre les valeurs valides.
Les enums résolvent ce problème : en tant qu'indication de type, un enum garantit que seuls les cas valides peuvent être passés, détectant les valeurs invalides au niveau du type plutôt que comme des bugs à l'exécution — une amélioration significative de la sécurité. Les enums avec support (avec des valeurs scalaires) s'intègrent proprement aux bases de données et à la sérialisation (from()/tryFrom() pour la conversion), et les enums peuvent avoir des méthodes (attachant du comportement à chaque cas, par exemple une label() ou une isActive()), les rendant puissants pour la modélisation de domaine.
Comprendre les enums purs par rapport aux enums avec support, leurs méthodes, et comment ils remplacent l'ancienne approche sujette aux erreurs utilisant les constantes/chaînes est une connaissance importante pour écrire du PHP moderne et type-safe — puisque les enums sont maintenant la façon idiomatique de modéliser des ensembles de valeurs fixes et sont largement utilisés dans les frameworks et applications actuels, les maîtriser reflète une maîtrise du PHP moderne et la capacité à écrire un code plus sûr, plus expressif et auto-documenté qui prévient toute une classe de bugs de valeurs invalides.