L’opérateur Pipe PHP 8.5 : Simplifier les chaînes de code

PHP a toujours été un langage plein de surprises. Certains le croyaient dépassé. Pourtant, à chaque nouvelle version, il nous rappelle qu’il a plus d’un tour dans son sac. Avec PHP 8.5, sorti récemment, une petite nouveauté attire l’attention de tous les développeurs : l’opérateur pipe (ou “pipe operator”).

À première vue, ce simple symbole |> pourrait passer inaperçu, mais il change en réalité profondément la manière d’enchaîner les fonctions et de rendre le code plus clair, plus fluide et plus lisible.

Si vous débutez en PHP, pas d’inquiétude : nous allons tout reprendre depuis le début, calmement, avec des exemples concrets. L’objectif, c’est qu’à la fin de cet article, vous puissiez comprendre le principe du pipe, l’utiliser dans vos projets et même apprécier la philosophie qui se cache derrière.

Avant d’aller plus loin, imaginez ceci :
Vous cuisinez un plat. Vous prenez une carotte, vous l’épluchez, vous la coupez, puis vous la mettez à cuire. Chaque étape transforme votre ingrédient pour le rapprocher du résultat final. Eh bien, l’opérateur pipe fonctionne exactement sur le même principe : il permet de faire circuler une donnée à travers une série d’opérations, sans avoir besoin d’imbrications compliquées ou de variables temporaires partout.

En somme, le pipe rend le code PHP plus… naturel. Et vous allez voir, ça change vraiment la vie.

Comprendre la logique du “pipe” : un héritage d’autres langages

Le pipe operator n’est pas une invention purement PHP. Il existe depuis longtemps dans d’autres langages, comme Elixir, F#, ou JavaScript (via une proposition récente). L’idée est toujours la même : prendre le résultat d’une expression et le passer comme argument à la suivante, dans une syntaxe plus lisible.

Prenons un exemple sans pipe. Voici un code tout à fait classique en PHP :

$result = strtoupper(trim(htmlspecialchars($input)));

Ce code prend une donnée $input, la nettoie (htmlspecialchars), enlève les espaces (trim) et met tout en majuscules (strtoupper).

Mais avouez-le : on a souvent du mal à lire ce genre de chaîne d’appels. Les parenthèses s’empilent, on lit de droite à gauche, et on finit par se demander quelle fonction s’applique d’abord.

Maintenant, avec le pipe operator de PHP 8.5, on peut écrire :

$result = $input 
    |> htmlspecialchars(_)
    |> trim(_)
    |> strtoupper(_);

Et là, magie. Le code se lit dans le sens naturel de la pensée : on prend $input, on le nettoie, on le “trim”, on le met en majuscules. C’est exactement comme lire une recette étape par étape, sans avoir à suivre un casse-tête de parenthèses.

L’opérateur |> fait passer la valeur située à gauche du pipe à l’expression qui se trouve à droite, en remplaçant le symbole _ (le fameux “placeholder”) par cette valeur. Ce caractère _ devient en quelque sorte une place réservée pour la donnée qui circule dans la chaîne.

Décortiquons ce que l’opérateur PIPE fait réellement

Techniquement, chaque fois que vous écrivez :

$a |> f(_);

cela revient à écrire :

f($a);

Autrement dit, le pipe ne crée pas de magie. Il reformule simplement votre intention de manière plus lisible. Ce n’est donc pas un nouvel opérateur “fonctionnel” dans le sens strict, mais un sucre syntaxique, c’est-à-dire une façon plus agréable d’écrire ce que vous faisiez déjà.

Et parfois, ce sucre-là change tout. Prenons un exemple un peu plus concret, tiré d’un petit script qu’on trouve souvent dans la vie réelle : formater une chaîne pour la rendre “SEO-friendly”.

Exemple concret : transformer un titre en slug propre

Avant PHP 8.5 :

$slug = strtolower(trim(preg_replace('/[^a-z0-9]+/', '-', remove_accents($title)), '-'));

Ce code fonctionne très bien, mais il est illisible. On ne comprend rien du premier coup d’œil, même quand on a l’habitude.

Avec l’opérateur pipe, tout devient limpide :

$slug = $title
    |> remove_accents(_)
    |> preg_replace('/[^a-z0-9]+/', '-', _)
    |> trim(_, '-')
    |> strtolower(_);

Là, on comprend immédiatement ce qui se passe.

On prend le titre, on enlève les accents, on remplace les caractères spéciaux, on supprime les tirets inutiles, et on met tout en minuscule. Pas besoin d’explications supplémentaires : le code parle de lui-même.

Et c’est bien là la force du pipe : rendre votre code expressif.

Quand on relit ce genre de script six mois plus tard, on comprend directement la logique, sans avoir à déchiffrer un enchevêtrement de parenthèses.

Une avancée majeure pour PHP

On pourrait se dire : “Oui bon, ce n’est qu’un opérateur de plus.” Mais en réalité, cette petite nouveauté traduit un grand pas vers une écriture fonctionnelle de PHP.

Le paradigme fonctionnel consiste à enchaîner des transformations de données sans modifier d’état intermédiaire. Au lieu d’avoir des variables temporaires du type :

$data = step1($input);
$data = step2($data);
$data = step3($data);

on peut désormais simplement écrire :

$result = $input 
    |> step1(_)
    |> step2(_)
    |> step3(_);

C’est plus élégant, plus compact et plus intuitif. Et au-delà du style, cela réduit les erreurs. Moins de variables, moins de confusion, moins de risque de réutiliser une mauvaise donnée par inadvertance.

On peut presque dire que PHP, avec cet opérateur, se met au yoga : il devient plus fluide, plus zen, plus lisible. Et ça fait du bien.

Pour la petite histoire, l’introduction du pipe operator dans PHP n’a pas été immédiate. L’idée traînait dans les discussions de la communauté depuis plusieurs années. Certains y voyaient une influence trop marquée de JavaScript ou de Hack (le langage de Facebook basé sur PHP), d’autres trouvaient que cela alourdissait la grammaire du langage.

Mais au fil du temps, la demande est devenue si forte — surtout chez les développeurs modernes qui utilisent des frameworks fonctionnels ou des librairies de transformation de données — que l’équipe de PHP a fini par se dire : “Allez, on se lance.” Et comme souvent, les réfractaires d’hier en sont aujourd’hui les plus fervents utilisateurs.

C’est un peu comme les gens qui râlaient quand le sucre en morceaux est apparu : “C’est inutile !” disaient-ils. Puis ils ont goûté à la praticité…

Où et quand l’utiliser ?

L’opérateur pipe n’a pas vocation à remplacer tous vos appels de fonctions. Il brille surtout quand vous devez enchaîner plusieurs transformations simples sur une donnée. Par exemple :

• lors du traitement de texte ou de formulaires,
• dans la préparation de données avant un affichage,
• pour la construction de requêtes complexes,
• ou encore dans des pipelines de validation.

En revanche, si votre logique repose sur des conditions, des boucles ou des manipulations d’état complexes, le pipe n’est pas toujours pertinent. Il faut l’utiliser comme un outil de clarté, pas comme une règle absolue.

Et niveau performances ?

Bonne question, car derrière la syntaxe agréable, le pipe n’ajoute aucune couche de calcul supplémentaire. Le moteur PHP 8.5 traduit simplement l’expression |> en un appel de fonction classique au moment de la compilation.

Autrement dit : aucun impact sur la performance. C’est juste une autre façon d’écrire le même code, sans surcoût.

D’ailleurs, certains développeurs s’amusent déjà à comparer le gain de temps de lecture. Et là, la différence est flagrante : les scripts écrits avec |> se lisent souvent deux à trois fois plus vite à la relecture. Et mine de rien, sur un projet de plusieurs milliers de lignes, ce confort-là n’a pas de prix.

Exercice pratique

Essayons ensemble un petit exercice pour bien comprendre comment ça marche. Imaginons qu’on veuille afficher la longueur d’une phrase après avoir nettoyé ses espaces inutiles et enlevé les balises HTML.

Sans pipe :

$length = strlen(trim(strip_tags($phrase)));

Avec pipe :

$length = $phrase
    |> strip_tags(_)
    |> trim(_)
    |> strlen(_);

La deuxième version est beaucoup plus claire, surtout quand vous débutez. On voit immédiatement les étapes : d’abord on enlève les balises, ensuite on nettoie les espaces, enfin on compte le nombre de caractères.

Et c’est ça, au fond, la promesse du pipe operator : rendre le code plus humain.

Créer ses propres fonctions pour utiliser l’opérateur pipe de PHP 8.5

Jusqu’ici, nous avons vu comment le pipe |> peut rendre votre code plus lisible lorsque vous enchaînez plusieurs fonctions natives de PHP. Mais il serait dommage de s’arrêter là. Le vrai pouvoir du pipe se révèle lorsque vous l’utilisez avec vos propres fonctions.

Prenons un cas simple : vous gérez un petit site web et vous souhaitez traiter des chaînes de texte avant de les enregistrer en base de données. Vous décidez de créer trois fonctions :

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

function clean_spaces($text) {
    return trim($text);
}

function remove_html($text) {
    return strip_tags($text);
}

function shorten($text) {
    return substr($text, 0, 50);
}

Sans le pipe, votre code ressemblerait à ceci :

$result = shorten(remove_html(clean_spaces($input)));

Encore une fois, il faut lire à l’envers, et pour un œil débutant, cela ressemble vite à un plat de spaghettis froids.

Avec l’opérateur pipe de PHP 8.5, tout devient fluide :

$result = $input
    |> clean_spaces(_)
    |> remove_html(_)
    |> shorten(_);

Ce code raconte une histoire : on nettoie les espaces, on enlève les balises HTML, on raccourcit le texte. Pas de mystère, pas de parenthèses en cascade. Et si un collègue reprend votre projet six mois plus tard, il comprendra votre intention immédiatement.

C’est ça, la beauté du pipe : il réintroduit la logique humaine dans la lecture du code.

Cas pratique : pipeline de validation d’un formulaire

Passons à un exemple un peu plus concret, qu’on rencontre souvent dans les projets web : la validation de formulaires. Imaginez un formulaire d’inscription avec un champ “email”. Vous voulez :

1. Nettoyer la donnée reçue.
2. Vérifier que l’adresse est bien au bon format.
3. La convertir en minuscule avant de l’enregistrer.

Avant PHP 8.5, vous auriez probablement fait ceci :

$email = trim($_POST['email']);
$email = filter_var($email, FILTER_VALIDATE_EMAIL);
$email = strtolower($email);

C’est correct, mais un peu verbeux. Et puis, on manipule plusieurs fois la même variable. Voici la version moderne avec l’opérateur pipe :

$email = $_POST['email']
    |> trim(_)
    |> filter_var(_, FILTER_VALIDATE_EMAIL)
    |> strtolower(_);

Ce petit changement rend le code plus lisible et réduit les erreurs. Vous pouvez même aller plus loin et enchaîner des fonctions anonymes ou des callbacks.

Par exemple, imaginons qu’on veuille loguer chaque étape pour le débogage :

$email = $_POST['email']
    |> trim(_)
    |> (fn($x) => log_value('Après trim', $x))(_)
    |> filter_var(_, FILTER_VALIDATE_EMAIL)
    |> strtolower(_);

Chaque fonction reçoit la donnée, l’affiche (ou la stocke), puis la passe à l’étape suivante. C’est un pipeline de transformation, tout comme dans un flux de données.

Une autre illustration : préparer des données pour une API

Le pipe devient encore plus intéressant lorsqu’il s’agit de chaîner des transformations complexes. Prenons un exemple courant : préparer une réponse JSON pour une API.

Avant PHP 8.5 :

$response = json_encode(
    array_map('htmlspecialchars', array_filter($data, 'is_string'))
);

C’est efficace mais pas franchement intuitif. Voici la même chose, écrite avec l’opérateur pipe :

$response = $data
    |> array_filter(_, 'is_string')
    |> array_map('htmlspecialchars', _)
    |> json_encode(_);

C’est comme si votre code vous parlait : “Je filtre les chaînes, je les nettoie, puis je les encode en JSON.”

Et même si vous n’êtes pas un développeur chevronné, vous pouvez comprendre le processus d’un simple coup d’œil. C’est exactement ce qu’on recherche lorsqu’on écrit du code collaboratif.

Le pipe et les fonctions anonymes : un duo puissant

L’un des aspects les plus intéressants du pipe est sa compatibilité avec les fonctions anonymes (closures). Cela permet d’écrire du code plus dynamique, sans forcément définir une fonction nommée à chaque fois.

Exemple : imaginons que vous vouliez transformer une liste de prix en ajoutant la TVA, puis calculer la somme totale.

Sans pipe :

$total = array_sum(array_map(fn($p) => $p * 1.2, $prices));

Avec pipe :

$total = $prices
    |> array_map(fn($p) => $p * 1.2, _)
    |> array_sum(_);

On distingue clairement les étapes :

1. Ajouter 20 % à chaque prix.
2. Faire la somme totale.

Le code devient auto-documenté. Et cette notion d’auto-documentation, c’est exactement ce que les grands projets recherchent. Quand le code explique lui-même ce qu’il fait, il n’a plus besoin de commentaires inutiles.

Les erreurs fréquentes avec l’opérateur pipe en PHP 8.5

Même si le pipe est pratique, il faut connaître ses limites. Voici les erreurs les plus courantes chez les débutants :

1. Oublier le symbole _
Le pipe ne devine pas automatiquement où insérer la valeur. Par exemple, ceci ne fonctionne pas :

$value = 5 |> add(10);

Il faut écrire :

$value = 5 |> add(_, 10);

Ainsi, _ est remplacé par 5, et l’appel devient add(5, 10).

2. Croire que le pipe crée des variables temporaires
Ce n’est pas le cas. Il enchaîne simplement les fonctions. Chaque pipe renvoie le résultat de l’expression précédente.

3. Tenter de l’utiliser avec des structures de contrôle
Le pipe n’est pas conçu pour les if, while ou for. Il s’utilise uniquement pour les expressions qui renvoient une valeur.

Travailler sans PHP 8.5 : existe-t-il une alternative ?

Tout le monde n’a pas encore migré vers PHP 8.5. Mais bonne nouvelle : vous pouvez simuler le comportement du pipe grâce à une fonction intermédiaire.

Voici un petit hack fonctionnel :

function pipe($value, ...$functions) {
    foreach ($functions as $fn) {
        $value = $fn($value);
    }
    return $value;
}

Et vous pouvez l’utiliser ainsi :

$result = pipe(
    $input,
    'trim',
    'htmlspecialchars',
    'strtoupper'
);

Ce n’est pas aussi élégant que le vrai |>, mais le principe est identique. D’ailleurs, certains frameworks PHP utilisaient déjà cette logique avant l’arrivée officielle du pipe. On peut citer Laravel Collections, par exemple, qui propose une méthode ->pipe() depuis plusieurs années. Autrement dit, l’idée n’est pas nouvelle : PHP 8.5 ne fait que la généraliser au niveau du langage.

Le pipe, une porte ouverte à un PHP plus fonctionnel

En vérité, le pipe n’est pas qu’un outil syntaxique. C’est un symbole de transformation dans la philosophie même du langage. Pendant longtemps, PHP a été perçu comme un langage procédural ou orienté objet, mais rarement comme un langage fonctionnel.

Avec |>, cette frontière commence à s’effacer.

De plus en plus de développeurs adoptent une écriture pure, prévisible et sans effets de bord, où les données circulent d’une fonction à l’autre, sans être modifiées en place. C’est une approche plus propre, plus testable et plus robuste à long terme.

Et quand on y pense, ce style d’écriture n’est pas réservé aux experts : il se rapproche de la manière dont notre cerveau conçoit les étapes d’un traitement. “Je prends ceci, je fais cela, puis cela.” C’est linéaire, clair et presque narratif.

Le pipe ne fait pas tout, mais il clarifie votre logique mentale. Et ça, c’est un gain considérable.

Un petit symbole pour le développeur, un grand pas pour PHP

Avec l’arrivée du pipe operator dans PHP 8.5, le langage franchit une étape décisive vers une écriture plus élégante, lisible et moderne. Ce n’est pas un gadget. C’est une nouvelle manière de penser la transformation des données.

En permettant d’enchaîner les fonctions sans imbrication ni variables intermédiaires, le pipe nous rapproche d’un code plus fluide, plus expressif, et surtout plus humain.

Les développeurs débutants y gagnent en clarté. Les développeurs expérimentés y gagnent en productivité. Et l’ensemble de la communauté PHP y gagne une nouvelle corde à son arc, plus proche de la simplicité des langages modernes.

Si vous débutez, expérimentez sans crainte. Prenez un petit script, remplacez vos chaînes de fonctions par des pipes, et regardez le résultat. Vous verrez : votre code respirera mieux, et vous aussi.

Le pipe n’est pas juste un opérateur, c’est une philosophie de lisibilité. Et croyez-moi : une fois que vous y aurez goûté, vous n’aurez plus envie de revenir en arrière.

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr