PHP 8.5 est désormais disponible avec une fonctionnalité très attendue : l’opérateur pipeUne petite fonctionnalité au potentiel énorme mais qui a pris des années à voir le jour
La sortie de la version 8.5 de PHP était prévue pour ce mois de novembre et l’annonce de confirmation est tombée il y a peu. Cette mouture vient une autre fonctionnalité très attendue : l'opérateur pipe (|>). Il s'agit d'une petite fonctionnalité au potentiel énorme, mais qui a tout de même pris des années à voir le jour.
L'opérateur pipe (|>), introduit dans PHP 8.5, permet d'enchaîner les appels de fonction de manière plus lisible et linéaire. A date, il est limité aux fonctions acceptant un seul argument obligatoire.
Avantages de l'opérateur pipe PHP
Lisibilité améliorée et flux naturel : l'opérateur pipe permet un flux de données de gauche à droite, reflétant la manière dont on traiterait naturellement des informations ou suivrait une séquence d'instructions. Cela élimine la « pyramide de la mort » souvent associée aux appels de fonctions profondément imbriqués.
| Code PHP : | Sélectionner tout |
1 2 3 4 5 6 7 |
<?php
// Sans opérateur pipe (appels imbriqués)
$result = trim(str_shuffle(strtoupper('Hello World')));
// Avec opérateur pipe
$result = 'Hello World' |> strtoupper(...) |> str_shuffle(...) |> trim(...); |
Élimination des variables temporaires : Cela réduit le besoin de variables intermédiaires pour stocker les résultats de chaque étape d'un pipeline de transformation de données, ce qui permet d'obtenir un code plus propre et plus concis.
| Code PHP : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 |
<?php
// Sans opérateur pipe (utilisation de variables temporaires)
$email = "TEST@EXAMPLE.COM";
$email = trim($email);
$email = strtolower($email);
sendEmail($email);
// Avec opérateur pipe
"TEST@EXAMPLE.COM" |> trim(...) |> strtolower(...) |> sendEmail(...); |
Maintenance et débogage améliorés du code : Chaque étape d'une opération en pipeline est davantage isolée, ce qui facilite le test, le débogage et la modification des transformations individuelles sans affecter l'ensemble de la chaîne. Cela crée également une séquence d'opérations auto-documentée.
| Code PHP : | Sélectionner tout |
1 2 3 4 5 6 |
<?php
$numbers = [1, 2, 3, 4, 5]
|> (fn($xs) => array_map(fn($n) => $n * 2, $xs)) // Doubler chaque nombre
|> (fn($xs) => array_filter($xs, fn($n) => $n > 5)); // Filtrer les nombres supérieurs à 5
// Result: [6, 8, 10] |
Facilite les modèles de programmation fonctionnelle : l'opérateur pipe encourage un style de programmation plus fonctionnel, dans lequel les données sont transformées à travers une série de fonctions pures, ce qui rend le code plus prévisible et plus facile à tester.
| Code PHP : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 |
<?php
$title = 'Hello World';
$slug = $title
|> trim(...)
|> (fn($t) => preg_replace('/[^a-z0-9\s]/i', '', $t))
|> (fn($t) => str_replace(' ', '-', $t))
|> strtolower(...);
// Result: "hello-world" |
Inconvénients de l'opérateur pipe PHP
Limitation à un seul argument : L'opérateur pipe transmet la valeur de gauche comme premier argument à la fonction appelable de droite. Si une fonction nécessite plusieurs arguments obligatoires, elle ne peut pas être utilisée directement avec l'opérateur pipe sans wrapper.
| Code PHP : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 | // Exemple : array_splice nécessite plusieurs arguments obligatoires. $arr = [1, 2, 3, 4, 5]; // Cette portion de code ne fonctionnera pas directement : // $result = $arr |> array_splice(..., 1, 2); // Erreur : arguments manquants // $result = $arr |> fn($x) => array_splice($x, 1, 2); // $result is [1, 4, 5], original $arr is modified |
Fonctions qui modifient leurs paramètres par référence : Les fonctions qui modifient leurs arguments par référence (par exemple, array_pop(), sort()) ne peuvent généralement pas être utilisées directement avec l'opérateur pipe, car celui-ci transmet les valeurs par valeur. Il existe une exception pour certaines fonctions internes marquées @prefer-ref.
| Code PHP : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 | $stack = [1, 2, 3]; // Ceci renvoie une erreur : // $lastElement = $stack |> array_pop(...); // Il faut alors l'utiliser de manière traditionnelle ou au sein d'un Closure. // S’il est absolument nécessaire de le combiner avec une chaîne de pipe et de gérer la variable d'origine à l'extérieur. // Exemple: $lastElement = array_pop($stack); // $lastElement is 3, $stack is [1, 2] |
Les pipelines trop longs ou trop complexes nuisent à la lisibilité : Si les pipes améliorent la lisibilité des chaînes simples, les pipelines trop longs ou trop complexes comportant de nombreuses fermetures imbriquées peuvent devenir difficiles à comprendre et à déboguer.
| Code PHP : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 | // Pipeline potentiellement moins lisible et trop complexe : $value = " hello world " |> (fn($x) => trim($x)) |> (fn($x) => str_replace(' ', '-', $x)) |> (fn($x) => strtoupper($x)) |> (fn($x) => substr($x, 0, 5)) |> (fn($x) => strrev($x)); // Cela peut être plus difficile à suivre que de le décomposer en étapes plus petites ou d'utiliser des appels de fonction traditionnels. |
Débogage des valeurs intermédiaires : Le débogage des valeurs intermédiaires dans une chaîne de pipes nécessite de rompre la chaîne ou d'utiliser des variables temporaires ou var_dump() de manière stratégique, car vous ne pouvez pas inspecter directement la valeur après chaque opération de pipe sans modification.
| Code PHP : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 | $data = [1, 2, 3]; // Pour inspecter les valeurs intermédiaires, il est possible de procéder comme suit : $step1 = $data |> (fn($x) => array_map(fn($y) => $y * 2, $x)); var_dump($step1); // Inspect $step1 $step2 = $step1 |> (fn($x) => array_filter($x, fn($y) => $y > 3)); var_dump($step2); // Inspect $step2 // ... and so on. |
PHP est un langage de script polyvalent destiné au développement web. Le code PHP est généralement traité sur un serveur web par un interpréteur PHP implémenté sous forme de module, de démon ou d'exécutable CGI (Common Gateway Interface). Sur un serveur web, le résultat du code PHP interprété et exécuté, qui peut être n'importe quel type de données, telles que du code HTML généré ou des données d'image binaires, forme tout ou partie d'une réponse HTTP.
Il existe divers systèmes de modèles web, systèmes de gestion de contenu web et frameworks web qui peuvent être utilisés pour orchestrer ou faciliter la génération de cette réponse. En outre, PHP peut être utilisé pour de nombreuses tâches de programmation en dehors du contexte web, telles que les applications graphiques autonomes et le contrôle de drones. Le code PHP peut également être exécuté directement à partir de la ligne de commande.
Selon un rapport, en octobre 2024 (environ deux ans après l'arrêt de PHP 7 et 11 mois après la sortie de PHP 8.3), PHP 7 est toujours utilisé par 50,0 % des sites web PHP, ce qui est obsolète et connu pour être peu sûr. En outre, 13,2 % des sites web PHP utilisent PHP 5, encore plus obsolète (discontinué depuis plus de 5 ans) et peu sûr, et PHP 8.0, qui n'est plus pris en charge, est également très populaire, de sorte que la majorité des sites web PHP n'utilisent pas de versions prises en charge.
Source : Notes de version
Et vous ?
Que pensez-vous de cette nouvelle fonctionnalité du langage PHP ? Quels autres avantages et inconvénients entrevoyez-vous ?Voir aussi :
PHP 8.4 est disponible avec des hooks de propriétés, des objets paresseux, une visibilité asymétrique, un object API pour BCMath, de nouvelles fonctions pour les tableaux et une variété d'autres nouveautés PHP ne craint plus, examinons les changements de langage intervenus depuis la sortie de PHP 5.4, par Víctor Falcón Ruíz La popularité de PHP diminue-t-elle ? Le langage de script a atteint sa position la plus basse dans l'index TIOBE, tandis que C++ consolide sa place dans le top 3 après avoir éjecté Java
Vous avez lu gratuitement 182 articles depuis plus d'un an.
Soutenez le club developpez.com en souscrivant un abonnement pour que nous puissions continuer à vous proposer des publications.
Soutenez le club developpez.com en souscrivant un abonnement pour que nous puissions continuer à vous proposer des publications.