Le typage strict en PHP est une fonctionnalité introduite dans PHP 7 qui permet de renforcer les règles de typage des arguments et des valeurs de retour des fonctions et des méthodes. Par défaut, PHP utilise un typage dynamique et faible, ce qui signifie qu’il convertit les types de données de manière implicite lorsque cela est nécessaire. Le typage strict, en revanche, oblige les développeurs à respecter les types de données spécifiés, ce qui peut renforcer la robustesse et la prévisibilité du code.
Pour activer le typage strict dans un fichier PHP, on doit ajouter la ligne suivante au début du fichier, avant toute déclaration de code :
```
declare(strict_types=1);
```
Lorsque le typage strict est activé, PHP ne permet plus la conversion implicite des types de données définis dans les signatures de méthodes et de fonctions. Par exemple, si une fonction attend un entier (`int`) en argument, passer une chaîne de caractères contenant un nombre (`“42”`) générera une erreur de type.
Voici un exemple illustrant l’usage du typage strict :
```
declare(strict_types=1);
function add(int $a, int $b): int {
return $a + $b;
}
// Appel correct
echo add(3, 4); // affiche 7
// Appel incorrect
echo add(“3”, “4”); // TypeError: Argument 1 passed to add() must be of the type int, string given
?>
```
Dans cet exemple, la fonction `add` spécifie que ses arguments `$a` et `$b` doivent être de type `int`, et que la valeur de retour doit également être de type `int`. Si on tente de passer des chaînes de caractères, une erreur de type sera lancée.
Le typage strict s’applique également aux valeurs de retour des fonctions. Voici un exemple :
```
declare(strict_types=1);
function getNumber(): int {
return 5.6;
}
// Appel incorrect
echo getNumber(); // TypeError: Return value of getNumber() must be of the type int, float returned
```
Dans cet exemple, la fonction `getNumber` est censée retourner un entier (`int`). Cependant, elle retourne un nombre à virgule flottante (`float`), ce qui déclenche une erreur de type.
Le typage strict contribue à la rigueur du code et facilite le débogage et la maintenance en empêchant les erreurs subtiles dues à des conversions de type implicites. Cela permet également de tirer parti de l’auto-complétion et de la vérification des types dans les IDE modernes, améliorant ainsi la productivité des développeurs.
Sources :
1. [PHP: Types – Manual](https://www.php.net/manual/en/language.types.php)
2. [PHP: Type Declarations – Manual](https://www.php.net/manual/en/functions.arguments.php#functions.arguments.type-declaration)
3. [PHP: declare – Manual](https://www.php.net/manual/en/control-structures.declare.php)
Ces documents de la documentation officielle PHP fournissent des explications détaillées et des exemples sur le typage strict, les déclarations de type, et le comportement général des types en PHP.
