# true, false et null comme types autonomes PHP 8.2 : ce qu’ils sécurisent

> Une fonction qui ne retourne jamais que la valeur booléenne vraie mérite un type qui le dise exactement, plutôt qu'un simple bool laissant planer un doute.

- Auteur : Clément Hadrot
- Publié le : 2026-02-11
- Mis à jour le : 2026-02-11
- Catégorie : Astuces
- URL : https://wpmoderne.dev.wordpress-developpement.fr/tips/true-false-null-types-autonomes-php82-clarte/

## L’essentiel

- Trois types autonomes ajoutés au système de types PHP
- Documentent une fonction à valeur de retour constante
- Introduits par PHP 8.2, distincts des types disjonctifs DNF

Une fonction qui ne retourne jamais que la valeur booléenne vraie — parce qu'elle lève une exception dans tous les autres cas plutôt que de retourner faux — se documentait jusque-là avec un type `bool` classique, qui laisse pourtant planer un doute sur la possibilité d'un retour à faux. PHP 8.2 comble cette imprécision en autorisant `true`, `false` et `null` comme types de retour ou de paramètre à part entière, et non plus seulement comme valeurs.

Ces trois types restent minimalistes par nature : ils ne décrivent qu'une seule valeur possible chacun. Leur intérêt tient justement à cette contrainte : ils rendent explicite qu'une fonction ne varie pas là où un lecteur pourrait s'attendre à une variation.

## Ce que chacun de ces types signifie précisément

Typer une fonction en `true` signifie qu'elle ne peut retourner que la valeur booléenne vraie, jamais faux ni aucune autre valeur. Le type `false` fonctionne symétriquement. Le type `null`, quant à lui, existait déjà de manière implicite via le point d'interrogation d'un type nullable (`?string`, par exemple), mais PHP 8.2 permet désormais de l'utiliser seul, pour une fonction qui ne retourne jamais que cette valeur unique.

## Un exemple : documenter une fonction de validation stricte

> L'essentiel à retenir : Trois types autonomes ajoutés au système de types PHP ; Documentent une fonction à valeur de retour constante ; Introduits par PHP 8.2, distincts des types disjonctifs DNF

Prenons une fonction utilitaire d'une extension qui valide un format de référence produit, et qui lève systématiquement une exception si le format est incorrect plutôt que de retourner un booléen ambigu :

```
function valider_reference_produit_stricte( string $reference ): true {
    if ( ! preg_match( '/^REF-[0-9]{6}$/', $reference ) ) {
        throw new InvalidArgumentException(
            sprintf( 'Référence produit invalide : %s', $reference )
        );
    }

    return true;
}
```

Le type `true` annonce, dès la signature, que cette fonction ne connaît que deux issues : retourner vrai, ou lever une exception. Un développeur qui l'appelle sait immédiatement qu'il n'a pas besoin de tester un retour à faux dans sa logique appelante — ce cas n'existe simplement pas selon la signature elle-même.

## Où ces types apportent réellement de la valeur

- Documenter une fonction de garde qui lève systématiquement une exception plutôt que de retourner un échec silencieux.
- Documenter une fonction qui, dans une version future du code, pourrait légitimement évoluer vers un type plus large — passer de `true` à `bool` reste un changement rétrocompatible pour les appelants existants.
- Clarifier une interface où certaines méthodes ne retournent jamais que `null`, par exemple un service qui journalise sans jamais rien retourner d'utile à l'appelant, en le distinguant d'un `void` qui interdirait tout `return` avec valeur.

## Ce que PHP 8.2 n'introduit pas en même temps

Il est facile de confondre ces trois types autonomes avec les types disjonctifs normaux (DNF, pour Disjunctive Normal Form), qui permettent de mélanger types union et types d'intersection dans une même déclaration, comme `(Countable&ArrayAccess)|null`. Cette seconde fonctionnalité est arrivée dans la même version, PHP 8.2, mais répond à un besoin distinct : combiner plusieurs contraintes de typage complexes, plutôt que d'isoler une valeur unique comme le font `true`, `false` et `null` pris séparément.

> Réserver ces types autonomes aux fonctions dont le comportement est réellement figé : dès qu'un retour à faux ou à une autre valeur devient plausible, mieux vaut revenir à un type plus large comme bool.

## Une limite à ne pas ignorer

Le type `false` autonome ne peut pas, à lui seul, remplacer un type union classique comme `string|false`, très répandu dans les fonctions historiques du langage qui retournent une valeur ou `false` en cas d'échec. Ce schéma reste un type union à deux possibilités, pas un type `false` isolé : la nuance compte au moment de choisir la bonne annotation pour une fonction qui imite ce comportement historique.

## Notre verdict

Ces trois types autonomes introduits par PHP 8.2 ne changent rien au comportement à l'exécution d'un code qui fonctionnait déjà correctement : leur seul apport est documentaire, mais ce n'est pas un détail mineur. Une signature qui annonce `true` plutôt que `bool` dit exactement ce qu'un appelant peut attendre, sans avoir à lire le corps de la fonction pour le vérifier.