PHP moderne supporte les déclarations de types sur les paramètres de fonction, les valeurs de retour et les propriétés de classe — et declare(strict_types=1) pour les appliquer strictement. Ensemble, ils apportent une grande partie de la sécurité des langages typés statiquement à PHP, en détectant les bugs rapidement.
{
= ;
? = ;
{
->balance += ;
}
{
->balance;
}
}
Vous pouvez typer les paramètres, les valeurs de retour et les propriétés de classe. Les types incluent les scalaires (int, float, string, bool), les classes/interfaces, array, ?Type (nullable) et void.
function process(int|string $id): User|null { } // union type — int OR string
function handle(Countable&Iterator $x): void { } // intersection (PHP 8.1) — BOTH
function get(): static { } // return the called class's type
function nothing(): never { } // never returns (throws/exits, PHP 8.1)
PHP 8 a ajouté les types union (int|string), les types intersection et les types de retour spéciaux (static, never).
<?php
declare(strict_types=1); // MUST be the first statement in the file
function add(int $a, int $b): int { return $a + $b; }
add(5, 3); // ✅ 8
add("5", 3); // ❌ TypeError — strict_types REJECTS the string (no coercion)
WITHOUT strict_types (default "coercive" mode):
add("5", 3) → "5" is silently coerced to int 5 → returns 8 (lenient, can hide bugs)
WITH strict_types=1:
add("5", 3) → TypeError immediately (must pass the exact declared type)
declare(strict_types=1) passe de la coercition permissive à l'application stricte — PHP rejette les incompatibilités de type au lieu de les convertir silencieusement. Cela détecte les bugs que la coercition cacherait.
Les déclarations de types et les types stricts sont importants pour écrire du PHP moderne robuste et maintenable, et ils représentent une évolution majeure du langage au-delà de ses origines faiblement typées.
Les déclarations de types sur les paramètres, les retours et les propriétés rendent le code auto-documenté (les signatures déclarent clairement les attentes) et permettent à PHP de détecter les erreurs de type automatiquement, tandis que les additions modernes (types union, types nullable) rendent les signatures précises.
La pratique la plus importante est declare(strict_types=1) : elle fait passer PHP de la coercition permissive (où "5" devient silencieusement 5, cachant potentiellement des bugs) à l'application stricte (rejetant les types mal assortis avec une TypeError claire) — un outil clé pour détecter les bugs rapidement et écrire du code fiable, et la valeur par défaut moderne recommandée.
Comprendre les déclarations de types et utiliser les types stricts est une connaissance professionnelle quotidienne pour le développement PHP moderne — cela apporte une grande partie de la sécurité des langages typés statiquement à PHP, rendant le code plus robuste et plus facile à maintenir.
Comme les frameworks PHP modernes et les bases de code bien écrites utilisent le typage intensément (et les types stricts partout), maîtriser cela est essentiel pour écrire et travailler avec du PHP contemporain de qualité, distinguant le code moderne type-safe du style faiblement typé et sujet aux erreurs du PHP plus ancien.