{"id":48633,"date":"2021-09-24T19:30:38","date_gmt":"2021-09-24T17:30:38","guid":{"rendered":"https:\/\/kinsta.com\/?p=100177"},"modified":"2023-08-22T09:59:11","modified_gmt":"2023-08-22T08:59:11","slug":"transpiler-php","status":"publish","type":"post","link":"https:\/\/kinsta.com\/fr\/blog\/transpiler-php\/","title":{"rendered":"Le guide ultime pour transpiler le code PHP"},"content":{"rendered":"

Dans des circonstances id\u00e9ales, nous devrions utiliser PHP 8.0<\/a> (la derni\u00e8re version au moment d’\u00e9crire ces lignes) pour tous nos sites et le mettre \u00e0 jour d\u00e8s qu’une nouvelle version est publi\u00e9e. Cependant, les d\u00e9veloppeurs devront souvent travailler avec des versions ant\u00e9rieures de PHP, par exemple lorsqu’ils cr\u00e9ent une extension publique pour WordPress<\/a> ou qu’ils travaillent avec du code h\u00e9rit\u00e9 qui emp\u00eache la mise \u00e0 jour de l’environnement du serveur web.<\/p>\n

Dans ces situations, nous pourrions abandonner l’espoir d’utiliser le dernier code PHP. Mais il existe une meilleure alternative : nous pouvons toujours \u00e9crire notre code source avec PHP 8.0 et le transpiler vers une version ant\u00e9rieure de PHP – m\u00eame vers PHP 7.1.<\/p>\n

Dans ce guide, nous allons vous apprendre tout ce que vous devez savoir sur la transpilation du code PHP.<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Qu’est-ce que la transpilation ?<\/h2>\n

La transpilation convertit le code source d’un langage de programmation<\/a> en un code source \u00e9quivalent du m\u00eame langage de programmation ou d’un langage diff\u00e9rent.<\/p>\n

La transpilation n’est pas un concept nouveau dans le d\u00e9veloppement web : les d\u00e9veloppeurs c\u00f4t\u00e9 client connaissent probablement Babel<\/a>, un transpileur pour le code JavaScript.<\/p>\n

Babel convertit le code JavaScript de la version moderne ECMAScript 2015+ en une version h\u00e9rit\u00e9e compatible avec les anciens navigateurs. Par exemple, \u00e9tant donn\u00e9 une fonction fl\u00e8che ES2015 :<\/p>\n

[2, 4, 6].map((n) => n * 2);\n<\/code><\/pre>\n
…Babel la convertira en sa version ES5 :<\/p>\n
[2, 4, 6].map(function(n) {\n  return n * 2;\n});\n<\/code><\/pre>\n
Qu’est-ce que la transpilation PHP ?<\/h3>\n
Ce qui est potentiellement nouveau dans le d\u00e9veloppement web, c’est la possibilit\u00e9 de transpiler le code c\u00f4t\u00e9 serveur, en particulier PHP.<\/p>\n
La transpilation PHP fonctionne de la m\u00eame mani\u00e8re que la transpilation JavaScript : le code source d’une version moderne de PHP<\/a> est converti en un code \u00e9quivalent pour une version plus ancienne de PHP.<\/p>\n
En suivant le m\u00eame exemple que pr\u00e9c\u00e9demment, une fonction fl\u00e8che de PHP 7.4 :<\/p>\n
$nums = array_map(fn($n) => $n * 2, [2, 4, 6]) ;\n<\/code><\/pre>\n
…peut \u00eatre transpil\u00e9e dans sa version \u00e9quivalente de PHP 7.3 :<\/p>\n
$nums = array_map(\n  function ($n) {\n    return $n * 2;\n  },\n  [2, 4, 6]\n);\n<\/code><\/pre>\n
Les fonctions fl\u00e9ch\u00e9es peuvent \u00eatre transpil\u00e9es car elles sont du syntaxic sugar<\/a>, c’est-\u00e0-dire une nouvelle syntaxe pour produire un comportement existant.<\/p>\n
Cependant, il existe aussi de nouvelles fonctions qui cr\u00e9ent un nouveau comportement, et \u00e0 ce titre, il n’y aura pas de code \u00e9quivalent pour les versions pr\u00e9c\u00e9dentes de PHP. C’est le cas des types d’union<\/a>, introduits dans PHP 8.0 :<\/p>\n
function someFunction(float|int $param): string|float|int|null\n{\n  \/\/ ...\n}\n<\/code><\/pre>\n
Dans ces situations, la transpilation peut toujours \u00eatre effectu\u00e9e tant que la nouvelle fonctionnalit\u00e9 est n\u00e9cessaire pour le d\u00e9veloppement mais pas pour la production. Dans ce cas, nous pouvons simplement supprimer compl\u00e8tement la fonctionnalit\u00e9 du code transpil\u00e9 sans cons\u00e9quences graves.<\/p>\n
Un exemple est celui des types d’union. Cette fonctionnalit\u00e9 est utilis\u00e9e pour v\u00e9rifier qu’il n’y a pas d’incompatibilit\u00e9 entre le type d’entr\u00e9e et sa valeur fournie, ce qui permet d’\u00e9viter les bogues. S’il y a un conflit avec les types, il y aura une erreur d\u00e9j\u00e0 dans le d\u00e9veloppement, et nous devrions l’attraper et la corriger avant que le code n’atteigne la production.<\/p>\n
Nous pouvons donc nous permettre de supprimer la fonctionnalit\u00e9 du code pour la production :<\/p>\n
function someFunction($param)\n{\n  \/\/ ...\n}\n<\/code><\/pre>\n
Si l’erreur se produit quand m\u00eame en production, le message d’erreur sera moins pr\u00e9cis que si nous avions des types d’union. Cependant, cet inconv\u00e9nient potentiel est compens\u00e9 par la possibilit\u00e9 d’utiliser les types d’union en premier lieu.<\/p>\n\n
Avantages de la transpilation du code PHP<\/h2>\n
La transpilation permet de coder une application en utilisant la derni\u00e8re version de PHP et de produire une version qui fonctionne \u00e9galement dans des environnements ex\u00e9cutant des versions plus anciennes de PHP.<\/p>\n
Cela peut \u00eatre particuli\u00e8rement utile pour les d\u00e9veloppeurs qui cr\u00e9ent des produits pour les anciens syst\u00e8mes de gestion de contenu (CMS)<\/a>. WordPress, par exemple, prend toujours officiellement en charge PHP 5.6<\/a> (m\u00eame s’il recommande PHP 7.4+). Le pourcentage de sites WordPress ex\u00e9cutant les versions 5.6 \u00e0 7.2 de PHP – qui sont toutes en fin de vie (End Of Life ou EOL), ce qui signifie qu’elles ne re\u00e7oivent plus de mises \u00e0 jour de s\u00e9curit\u00e9 – s’\u00e9l\u00e8ve \u00e0 34,8 %, et ceux fonctionnant avec une version de PHP autre que 8.0 \u00e0 99,5 % :<\/p>\n
\"Statistiques<\/a>
Statistiques d’utilisation de WordPress par version. Source de l’image : WordPress<\/a><\/figcaption><\/figure>\n
Par cons\u00e9quent, les th\u00e8mes et extensions WordPress destin\u00e9s \u00e0 un public mondial seront tr\u00e8s probablement cod\u00e9s avec une ancienne version de PHP pour augmenter leur port\u00e9e possible. Gr\u00e2ce \u00e0 la transpilation, ils pourraient \u00eatre cod\u00e9s avec PHP 8.0, et \u00eatre tout de m\u00eame publi\u00e9s pour une ancienne version de PHP, ciblant ainsi le plus grand nombre d’utilisateurs possible.<\/p>\n
En effet, toute application qui doit prendre en charge une version de PHP autre que la plus r\u00e9cente (m\u00eame dans la gamme des versions PHP actuellement prises en charge) peut en b\u00e9n\u00e9ficier.<\/p>\n
C’est le cas de Drupal, qui n\u00e9cessite PHP 7.3<\/a>. Gr\u00e2ce \u00e0 la transpilation, les d\u00e9veloppeurs peuvent cr\u00e9er des modules Drupal accessibles au public en utilisant PHP 8.0, et les publier avec PHP 7.3.<\/p>\n
Un autre exemple est la cr\u00e9ation de code personnalis\u00e9 pour les clients qui ne peuvent pas ex\u00e9cuter PHP 8.0 dans leur environnement pour une raison ou une autre. N\u00e9anmoins, gr\u00e2ce \u00e0 la transpilation, les d\u00e9veloppeurs peuvent toujours coder leurs produits livrables en utilisant PHP 8.0 et les ex\u00e9cuter sur ces anciens environnements.<\/p>\n
Quand transpiler PHP<\/h3>\n
Le code PHP peut toujours \u00eatre transpil\u00e9, sauf s’il contient une fonctionnalit\u00e9 PHP qui n’a pas d’\u00e9quivalent dans la version pr\u00e9c\u00e9dente de PHP.<\/p>\n
C’est peut-\u00eatre le cas des attributs<\/a>, introduits dans PHP 8.0 :<\/p>\n
#[SomeAttr]\nfunction someFunc() {}\n\n#[AnotherAttr]\nclass SomeClass {}<\/code><\/pre>\n
Dans l’exemple pr\u00e9c\u00e9dent utilisant les fonctions fl\u00e8ches, le code pouvait \u00eatre transpil\u00e9 car les fonctions fl\u00e8ches sont du syntaxic sugar. Les attributs, en revanche, cr\u00e9ent un comportement compl\u00e8tement nouveau. Ce comportement pourrait aussi \u00eatre reproduit avec PHP 7.4 et inf\u00e9rieur, mais seulement en le codant manuellement, c’est-\u00e0-dire pas automatiquement sur la base d’un outil ou d’un processus (l’IA pourrait fournir une solution, mais nous n’en sommes pas encore l\u00e0).<\/p>\n
Les attributs destin\u00e9s \u00e0 \u00eatre utilis\u00e9s pour le d\u00e9veloppement, tels que #[Deprecated]<\/code><\/a>peuvent \u00eatre supprim\u00e9s de la m\u00eame mani\u00e8re que les types d’union. Mais les attributs qui modifient le comportement de l’application en production ne peuvent pas \u00eatre supprim\u00e9s, et ils ne peuvent pas non plus \u00eatre directement transpil\u00e9s.<\/p>\n
\u00c0 ce jour, aucun transpilateur ne peut prendre du code avec des attributs PHP 8.0 et produire automatiquement son code \u00e9quivalent en PHP 7.4. Par cons\u00e9quent, si votre code PHP doit utiliser des attributs, il sera difficile, voire impossible, de le transpiler.<\/p>\n
Fonctionnalit\u00e9s PHP qui peuvent \u00eatre transpil\u00e9es<\/h3>\n
Ce sont les fonctionnalit\u00e9s de PHP 7.1 et plus qui peuvent actuellement \u00eatre transpil\u00e9es. Si votre code n’utilise que ces fonctionnalit\u00e9s, vous pouvez avoir la certitude que votre application transpil\u00e9e fonctionnera. Sinon, vous devrez \u00e9valuer si le code transpil\u00e9 produira des d\u00e9faillances.<\/p>\n\n\n\n\n\n\n\n\n\n
Version de PHP<\/span><\/th>\nCaract\u00e9ristiques<\/th>\n<\/tr>\n<\/thead>\n
7.1<\/td>\nTout<\/td>\n<\/tr>\n
7.2<\/td>\n– type objet<\/code><\/a>
\n– \u00e9largissement du type de param\u00e8tre<\/a>
\n– Drapeau PREG_UNMATCHED_AS_NULL<\/code> dans preg_match<\/code><\/a><\/td>\n<\/tr>\n
7.3<\/td>\n– Affectations de r\u00e9f\u00e9rence dans la d\u00e9structuration des list()<\/code><\/a> (sauf \u00e0 l’int\u00e9rieur de foreach<\/code> – #4376<\/a><\/em>)
\n– Syntaxe Heredoc et Nowdoc flexible<\/a>
\n– Virgules de fin dans les appels de fonctions<\/a>
\n– set(raw)cookie<\/code> accepte l’argument $option<\/a><\/td>\n<\/tr>\n
7.4<\/td>\n– Propri\u00e9t\u00e9s typ\u00e9es<\/a>
\n– Fonctions fl\u00e9ch\u00e9es<\/a>
\n– Op\u00e9rateur d’affectation \u00e0 coalescence nulle<\/a>
\n– D\u00e9ballage \u00e0 l’int\u00e9rieur des tableaux<\/a>
\n– S\u00e9parateur de litt\u00e9ral num\u00e9rique<\/a>
\n– strip_tags()<\/code>avec un tableau de noms de balises<\/a>
\n– types de retour covariants et types de param\u00e8tres contravariants<\/a><\/td>\n<\/tr>\n
8.0<\/td>\n– Types d’union<\/a>
\n– pseudo-type mixed<\/code><\/a>
\n– type de retour static<\/code><\/a>
\n– ::class<\/code> constante magique sur les objets <\/a>
\n– match<\/code> expressions <\/a>
\n– catch<\/code> exceptions uniquement par type <\/a>
\n– Op\u00e9rateur \u00e0 s\u00e9curit\u00e9 nulle<\/a>
\n– Promotion des propri\u00e9t\u00e9s du constructeur de classe<\/a>
\n– Virgules de fin dans les listes de param\u00e8tres et les listes d’use<\/code> fermetures<\/a><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Transpilateurs PHP<\/h2>\n
Actuellement, il existe un outil pour transpiler le code PHP : Rector<\/a>.<\/p>\n
Rector est un outil de reconstruction de PHP, qui convertit le code PHP sur la base de r\u00e8gles programmables. On entre le code source et l’ensemble des r\u00e8gles<\/a> \u00e0 ex\u00e9cuter, et Rector transformera le code.<\/p>\n
Rector s’utilise en ligne de commande et est install\u00e9 dans le projet via Composer. Une fois ex\u00e9cut\u00e9, Rector produira un \u00ab diff \u00bb (ajouts en vert, suppressions en rouge) du code avant et apr\u00e8s la conversion :<\/p>\n
\"Sortie<\/a>
Sortie \u00ab diff \u00bb de Rector<\/figcaption><\/figure>\n
Quelle version de PHP transpiler<\/h2>\n
Pour transpiler du code entre plusieurs versions de PHP, il faut cr\u00e9er les r\u00e8gles correspondantes.<\/p>\n
Aujourd’hui, la biblioth\u00e8que Rector comprend la plupart des r\u00e8gles pour transpiler du code dans la plage de PHP 8.0 \u00e0 7.1. Nous pouvons donc transpiler notre code PHP de mani\u00e8re fiable jusqu’\u00e0 la version 7.1.<\/p>\n
Il existe \u00e9galement des r\u00e8gles pour transpiler de PHP 7.1 \u00e0 7.0<\/a> et de 7.0 \u00e0 5.6<\/a>, mais elles ne sont pas exhaustives. Des travaux sont en cours pour les compl\u00e9ter, afin que nous puissions \u00e9ventuellement transpiler du code PHP jusqu’\u00e0 la version 5.6.<\/p>\n
Transpiler vs r\u00e9troporter<\/h2>\n
Le r\u00e9troportage (backporting) est similaire \u00e0 la transpilation (transpiling), mais plus simple. Le r\u00e9troportage de code ne repose pas n\u00e9cessairement sur les nouvelles fonctionnalit\u00e9s d’un langage. Au lieu de cela, la m\u00eame fonctionnalit\u00e9 peut \u00eatre fournie \u00e0 une ancienne version du langage simplement en copiant\/collant\/adaptant le code correspondant de la nouvelle version du langage.<\/p>\n
Par exemple, la fonction str_contains<\/code> a \u00e9t\u00e9 introduite dans PHP 8.0. La m\u00eame fonction pour PHP 7.4 et les versions inf\u00e9rieures peut \u00eatre facilement mise en \u0153uvre comme ceci :<\/p>\n
if (!defined('PHP_VERSION_ID') || (defined('PHP_VERSION_ID') && PHP_VERSION_ID < 80000)) {\n  if (!function_exists('str_contains')) {\n    \/**\n     * Checks if a string contains another\n     *\n     * @param string $haystack The string to search in\n     * @param string $needle The string to search\n     * @return boolean Returns TRUE if the needle was found in haystack, FALSE otherwise.\n     *\/\n    function str_contains(string $haystack, string $needle): bool\n    {\n      return strpos($haystack, $needle) !== false;\n    }\n  }\n}<\/code><\/pre>\n
Comme le r\u00e9troportage est plus simple que la transpilation, nous devrions opter pour cette solution chaque fois que le r\u00e9troportage fait l’affaire.<\/p>\n
En ce qui concerne la gamme entre PHP 8.0 et 7.1, nous pouvons utiliser les biblioth\u00e8ques polyfill de Symfony<\/a>:<\/p>\n