# Le système de types de PHP

> Le système de types PHP expliqué : types de données, déclarations de PHP 7.1 à 8.3, strict_types et comparaisons souples, avec exemples et lien avec la sécurité.

Source : https://phpsos.de/fr/php/typsystem/  
État : 25/10/2026  
Fournisseur : PHP SOS, Assistance d'urgence PHP et sécurité des serveurs. Aide immédiate par WhatsApp : https://wa.me/491736494914?text=Bonjour%20PHP%20SOS%2C%20nous%20avons%20besoin%20d%27aide%20avec%20notre%20serveur%20PHP.%20Entreprise%20%3A%20%E2%80%A6%20Site%20web%20%3A%20%E2%80%A6

**En bref :** PHP est typé dynamiquement : le type d'une valeur n'est fixé qu'à l'exécution, et sans autre précision, PHP convertit automatiquement les valeurs au besoin. Depuis PHP 7, les paramètres, les valeurs de retour et les propriétés peuvent cependant recevoir des types, et `declare(strict_types=1)` rend la vérification stricte. Qui connaît les règles et utilise les comparaisons strictes avec `===` évite toute une catégorie d'erreurs de logique et de sécurité.

## Typé dynamiquement, mais pas sans types

En PHP, il n'est pas nécessaire d'indiquer un type avec `$preis = 19.90;`. PHP reconnaît qu'il s'agit d'un nombre à virgule flottante. Si la valeur est ensuite concaténée avec une chaîne, PHP la convertit. Ce comportement s'appelle le type juggling, c'est-à-dire la conversion automatique de types. Il facilite l'entrée en matière, mais peut conduire à des résultats surprenants.

Pour les décideurs, cela compte, car de nombreuses applications PHP anciennes ont été écrites sans indications de types. Un tel code est plus difficile à contrôler et à moderniser. Les projets plus récents utilisent les types de façon systématique, ce qui rend les erreurs visibles plus tôt et rend vraiment efficace l'[analyse statique](https://phpsos.de/fr/php/statische-analyse/) avec des outils comme PHPStan ou Psalm.

## Les types de PHP en un coup d'œil

Le manuel PHP mentionne neuf types internes que peut avoir toute expression. On les répartit habituellement en trois groupes :

| Groupe | Types | Exemple |
|---|---|---|
| Types scalaires | `bool`, `int`, `float`, `string` | `true`, `42`, `3.5`, `"Text"` |
| Types composés | `array`, `object`, `callable` | `[1, 2]`, `new DateTime()` |
| Types particuliers | `null`, `resource` | `null`, un fichier ouvert |

Pour les vérifications de types, le manuel recommande les fonctions `is_*()` comme `is_int()`. Pour l'inspection, `get_debug_type()` convient bien : depuis PHP 8.0.0, elle renvoie les noms de types usuels, alors que l'ancienne `gettype()` renvoie par exemple `"integer"` et `"double"`.

À côté de la conversion automatique, il existe la conversion explicite : avec un cast comme `(int) $wert` ou avec `settype()`, le code détermine lui-même le type que doit avoir une valeur. C'est courant pour les saisies de formulaires, car tout ce qui arrive par `$_GET` ou `$_POST` est d'abord une chaîne ou un tableau. Un cast ne vérifie toutefois pas si la valeur avait un sens : `"abc"` devient silencieusement `0`. Pour les saisies, un véritable contrôle avec `filter_var()` est donc généralement le meilleur choix.

Les classes et les interfaces sont elles aussi des types en PHP. Une fonction peut donc exiger qu'un paramètre soit un objet d'une classe donnée ou qu'il respecte une interface donnée. La page [Programmation orientée objet en PHP](https://phpsos.de/fr/php/objektorientierung/) explique comment classes, interfaces et enums s'articulent.

## Déclarations de types : de PHP 7.1 à 8.3

Les déclarations de types fixent les valeurs qu'une fonction accepte et renvoie. Le système de types s'est enrichi au fil de nombreuses versions. Selon le journal des modifications du manuel, les possibilités suivantes ont notamment été ajoutées :

| Version | Nouveauté |
|---|---|
| 7.1.0 | types nullables (`?int`), `void`, `iterable` |
| 7.2.0 | `object` |
| 7.4.0 | propriétés de classe typées |
| 8.0.0 | types union (plusieurs types autorisés dans une même indication), `mixed`, type de retour `static` |
| 8.1.0 | types intersection (`A&B`), type de retour `never` |
| 8.2.0 | types DNF, type littéral `true`, `null` et `false` comme types autonomes |
| 8.3.0 | constantes de classe, d'interface, de trait et d'enum typées |

DNF signifie forme normale disjonctive et permet des combinaisons comme `(A&B)|null`. Pour qui planifie des versions de PHP, ce tableau montre aussi quelles fonctionnalités du langage une application exige.

## strict_types : conversion ou TypeError

Sans autre indication, PHP fonctionne en mode convertisseur. Une fonction avec des paramètres `int` accepte alors aussi `1.5` et en fait `1` ; depuis PHP 8.1, cette conversion avec perte est marquée comme obsolète. Avec `declare(strict_types=1)` en début de fichier, PHP lève à la place une `TypeError`.

```php
<?php
declare(strict_types=1);

function summe(int $a, int $b): int
{
    return $a + $b;
}

echo summe(1, 2);      // 3
echo summe(1.5, 2.5);  // TypeError, au lieu de 3 en silence
```

Deux subtilités sont importantes. Premièrement, `strict_types` s'applique aux appels effectués depuis le fichier où il figure, et non aux fonctions qui y sont définies. Si un fichier sans `strict_types` appelle la même fonction, la conversion a lieu. Deuxièmement, un entier est autorisé là où un nombre à virgule flottante est attendu, même en mode strict.

## Comparaisons souples et strictes

L'opérateur `==` compare après conversion de types, `===` compare la valeur et le type sans conversion. Le manuel recommande dans la plupart des cas `===` et `!==`, car les règles de conversion ne sont pas toujours évidentes.

```php
<?php
var_dump(0 == "a");    // PHP 7: true,  PHP 8: false
var_dump("1" == "01"); // true, les deux sont des chaînes numériques
var_dump("1" === "01");// false, même type, mais une autre chaîne
var_dump(1 == true);   // true
var_dump(1 === true);  // false
```

Avec PHP 8.0, les comparaisons entre nombres et chaînes non numériques sont devenues plus raisonnables. Des applications anciennes peuvent se comporter différemment après la mise à niveau, par exemple dans des blocs `switch`. L'expression `match`, également introduite avec PHP 8.0, compare toujours strictement. La façon dont les comparaisons souples mènent à des failles de sécurité, par exemple dans des contrôles de jetons ou de mots de passe, est décrite dans l'article [Type juggling : les comparaisons souples comme risque de sécurité](https://phpsos.de/fr/blog/type-juggling-php/).

## Types, mises à niveau et PHP2Shell

Un système de types strict rend le code d'application plus robuste, mais il ne protège pas contre les erreurs de l'interpréteur lui-même. Les failles PHP2Shell CVE-2026-109618 et CVE-2026-109619 se situent dans la gestion de la mémoire et des requêtes de PHP. Elles sont corrigées dans PHP 8.5.12, 8.4.27, 8.3.36 et 8.2.35 ; tous les processus PHP doivent ensuite redémarrer.

Le système de types joue néanmoins un rôle, à savoir lors de la mise à niveau. Les applications encore bloquées sur PHP 8.1 ou une version plus ancienne ne reçoivent plus de mises à jour officielles du projet PHP. Un code bien typé se porte nettement plus facilement vers une version prise en charge, car les outils détectent tôt les incompatibilités. Pour les projets plus anciens, notre [migration vers une version de PHP prise en charge](https://phpsos.de/fr/leistungen/php-migration-legacy/) vous accompagne.

> **Astuce:**
> Activez `strict_types` progressivement dans les fichiers nouveaux et remaniés. La sûreté de typage progresse ainsi, sans que l'ancien code ne casse d'un seul coup.

## Comment PHP SOS aide-t-il concrètement ?

- Nous vérifions quelle version de PHP votre application exige au minimum, et la comparons aux versions corrigées.
- Nous faisons passer une analyse statique sur le code et repérons les comparaisons souples dans les contrôles sensibles pour la sécurité.
- Nous planifions les mises à niveau de sorte que les règles de comparaison modifiées soient testées au préalable.
- Nous installons la mise à jour de PHP, redémarrons tous les workers et documentons l'état obtenu.


## Questions fréquentes

**PHP est-il fortement ou faiblement typé ?**  
PHP est typé dynamiquement : le type d'une variable n'est fixé qu'à l'exécution. Sans strict_types, PHP convertit les valeurs au besoin. Avec des déclarations de types et strict_types, le code peut toutefois devenir très strict.

**Que fait declare(strict_types=1) ?**  
Il désactive la conversion automatique des valeurs scalaires pour les appels effectués depuis le fichier concerné. Si une valeur ne correspond pas au type déclaré, PHP lève une TypeError. La seule exception est un entier là où un nombre à virgule flottante est attendu.

**Pourquoi 0 == "a" est-il faux en PHP 8, mais vrai en PHP 7 ?**  
Jusqu'à PHP 7, une chaîne non numérique comparée à un nombre était convertie en nombre : "a" devenait 0. Depuis PHP 8.0, PHP ne compare plus numériquement dans ce cas, et le résultat est false.

**Les types protègent-ils contre les failles de PHP lui-même ?**  
Non. Les types évitent des erreurs dans le code de votre application. Les failles de l'interpréteur comme PHP2Shell ne se comblent que par une mise à jour de PHP. Les fonctions de typage modernes supposent toutefois des versions de PHP récentes, ce qui est une bonne occasion de migrer.

## Sources

- [Manuel PHP : déclarations de types](https://www.php.net/manual/de/language.types.declarations.php)
- [Manuel PHP : introduction aux types](https://www.php.net/manual/de/language.types.intro.php)
- [Manuel PHP : opérateurs de comparaison](https://www.php.net/manual/de/language.operators.comparison.php)
- [Publication de PHP 8.0](https://www.php.net/releases/8.0/en.php)