# Nullsafe operator PHP 8 : simplifier une chaîne d’appels dans une fixture

> Une fixture qui navigue entre plusieurs objets liés multiplie les vérifications de nullité. PHP 8.0 propose un opérateur qui les regroupe en une ligne.

- Auteur : WordPress Développement
- Publié le : 2021-01-04
- Mis à jour le : 2021-01-04
- Catégorie : Tests
- URL : https://www.wpmoderne.fr/tests/nullsafe-operator-php-8-fixtures-tests/

## L’essentiel

- Une chaîne d'appels sécurisée sans if imbriqués
- Retourne null dès le premier maillon absent
- Remplace plusieurs vérifications par un seul opérateur

`?->` : deux caractères qui suffisent, depuis PHP 8.0, à remplacer une pyramide de vérifications `if ($x !== null)` imbriquées. Pour une fixture de test qui navigue entre plusieurs objets liés, un article, son auteur, l'organisation de cet auteur, cet opérateur change directement la lisibilité du code de préparation.

Une équipe qui vient de migrer un projet vers PHP 8.0 découvre souvent cet opérateur en lisant le changelog, sans immédiatement mesurer son intérêt pour les tests. C'est pourtant dans les fixtures, où les relations entre objets sont fréquentes et parfois partiellement définies, que son apport est le plus concret.

## Le problème avant PHP 8.0

```
function recupere_nom_organisation( ?Auteur $auteur ) {
    if ( $auteur === null ) {
        return null;
    }
    $organisation = $auteur->getOrganisation();
    if ( $organisation === null ) {
        return null;
    }
    return $organisation->getNom();
}
```

Cette fonction utilitaire, destinée à préparer une fixture d'article rattaché à un auteur lui-même rattaché à une organisation, doit vérifier chaque maillon de la chaîne avant de poursuivre. Dans un jeu de fixtures où certains auteurs n'ont volontairement pas d'organisation renseignée, pour tester ce cas précis, ces vérifications deviennent vite répétitives d'une fonction à l'autre.

## Avec l'opérateur nullsafe

> L'essentiel à retenir : Une chaîne d'appels sécurisée sans if imbriqués ; Retourne null dès le premier maillon absent ; Remplace plusieurs vérifications par un seul opérateur

```
function recupere_nom_organisation( ?Auteur $auteur ) {
    return $auteur?->getOrganisation()?->getNom();
}
```

Une seule ligne remplace les huit précédentes. Dès que `$auteur` vaut `null`, ou dès que `getOrganisation()` retourne `null`, l'expression entière s'arrête et retourne `null`, sans erreur ni avertissement. Le comportement est strictement identique à la version précédente, mais la lecture devient immédiate : on voit d'un coup d'œil la chaîne de relations parcourue.

## Un exemple appliqué à une fixture de test

```
public function test_affiche_nom_organisation_si_presente(): void {
    $organisation = new Organisation( 'Studio Créatif' );
    $auteur = new Auteur( 'Camille', $organisation );

    $this->assertSame(
        'Studio Créatif',
        $auteur?->getOrganisation()?->getNom()
    );
}

public function test_ne_plante_pas_sans_organisation(): void {
    $auteur = new Auteur( 'Camille', null );

    $this->assertNull( $auteur?->getOrganisation()?->getNom() );
}
```

Le second test vérifie précisément le cas limite qui, avant PHP 8.0, aurait nécessité une gestion explicite de la valeur nulle à chaque étape. Ici, l'expression se contente de refléter la structure réelle des données, y compris dans son cas dégradé.

## Ce que l'opérateur ne remplace pas

Le nullsafe operator court-circuite uniquement les appels de méthode et les accès de propriété qui suivent un maillon `null`. Il ne remplace pas une validation de type plus large, et il ne doit pas devenir un prétexte pour ignorer une valeur nulle qui, dans le contexte du test, représenterait en réalité une anomalie plutôt qu'un cas normal. Une fixture qui masque systématiquement les valeurs nulles avec cet opérateur, sans jamais tester explicitement le cas où une relation est absente, perd une partie de sa valeur de vérification.

> L'opérateur nullsafe rend le code plus court, pas plus permissif : il faut continuer à écrire un test dédié pour le cas où la chaîne s'interrompt, plutôt que de se contenter de l'absence d'erreur.

## Une limite à connaître : pas d'assignation

Contrairement à un accès en lecture, l'opérateur nullsafe ne peut pas être utilisé du côté gauche d'une assignation. Une tentative comme `$auteur?->organisation = $organisation;` ne fonctionne pas de la façon attendue et doit rester une vérification explicite si l'objectif est de modifier une propriété conditionnellement. Cette limite concerne davantage le code de production que les fixtures elles-mêmes, qui construisent généralement leurs objets par le constructeur plutôt que par assignation directe.

## Un gain de lisibilité mesurable sur les fixtures complexes

Sur un projet où les fixtures représentent des structures à trois ou quatre niveaux de relations, article, auteur, organisation, équipe, le gain n'est pas seulement esthétique : chaque niveau de vérification retiré réduit d'autant la surface où une faute de frappe ou un test mal écrit pourrait passer inaperçu. Une chaîne nullsafe se lit et se relit plus vite qu'une pyramide conditionnelle, ce qui compte particulièrement lors d'une revue de code rapide.

## En résumé

L'opérateur nullsafe de PHP 8.0 simplifie directement l'écriture de fixtures qui naviguent entre plusieurs objets potentiellement absents. Il ne change rien au comportement attendu, seulement à la longueur et à la lisibilité du code, ce qui en fait un candidat naturel dès qu'une équipe migre vers cette version et revisite ses utilitaires de préparation de données de test.