URL: https://linuxfr.org/news/php-7-4
Title: PHP 7.4
Authors: Nonolapéro
 Oliver, Davy Defaud, Yves Bourguignon, Nils Ratusznik, ZeroHeure, Julien Jorge, Dafyd, windu.2b, Ysabeau 🧶, bobble bubble, dourouc05 et Christophe "CHiPs" PETIT
Date: 2019年10月11日T23:15:48+02:00
License: CC By-SA
Tags: php, web, développement_web et php7
Score: 55
Il y a bien longtemps qu’une nouvelle version de PHP n’avait pas été commentée ici. En fait, depuis la sortie de la version 7.0 qui s’est faite dans la douleur après l’abandon de la version 6. Le langage sort désormais avec une nouvelle version chaque fin d’année. La rétrocompatibilité est un point qui n’est pas négligé d’une version à l’autre, d’où une évolution plutôt lente.
La majorité des logiciels peut migrer sans trop d’appréhension. Depuis plusieurs versions, l’amélioration des performances est un point essentiel du fait de la concurrence avec HHVM, développé par Facebook. Au final, cette version, qui est la dernière de la branche 7, apporte un système de type plus fort, plus de performance et fait en sorte de diminuer le code cérémonial, aka _boilerplate_.
----
[Une revue d’une grande partie des nouveautés](https://stitcher.io/blog/new-in-php-74)
[Site officiel de PHP](https://www.php.net/)
[Tout pour se préparer à PHP 7.4 (conférence forum PHP 2019)](https://afup.org/talks/3120-tout-pour-se-preparer-a-php-7-4)
[Liste des RFC de la version](https://wiki.php.net/rfc#php_74)
[PHP 8 et le JIT (conférence forum PHP 2019)](https://afup.org/talks/3015-php-8-et-just-in-time-compilation)
----
La version PHP 7.4 apporte de nombreuses fonctionnalités et en supprime une :
 
- [*null coalescing assignment operator*](https://wiki.php.net/rfc/null_coalesce_equal_operator), proposé par Midori Kocak ;
- [fonctions fléchées 2.0](https://wiki.php.net/rfc/arrow_functions_v2), proposées par Nikita Popov, Levi Morrison et Bob Weinand ([PR](https://github.com/php/php-src/pull/3941 "Pull Request")) ;
- [propriétés typées 2.0](https://wiki.php.net/rfc/typed_properties_v2), proposées par Nikita Popovet et Bob Weinand ([PR](https://github.com/php/php-src/pull/3734 "Pull Request")) ;
- [préchargement](https://wiki.php.net/rfc/preload), proposé par Dmitry Stogov ;
- [amélioration d’`openssl_random_pseudo_bytes()`](https://wiki.php.net/rfc/improve-openssl-random-pseudo-bytes), proposée par Sammy Kaye Powers ([PR](https://github.com/php/php-src/pull/3649 "Pull Request")) ;
- [références faibles](https://wiki.php.net/rfc/weakrefs) (_weak references_), proposées par _krakjoe_ ;
- [extension de hachage toujours disponible](https://wiki.php.net/rfc/permanent_hash_ext), proposée par Kalle Sommer Nielsen ;
- [FFI](https://wiki.php.net/rfc/ffi) (_Foreign Function Interface_), proposé par Dmitry Stogov ;
- [registre de hachage de mot de passe](https://wiki.php.net/rfc/password_registry), proposé par Sara Golemon ([PR](https://github.com/php/php-src/pull/3609 "Pull Request")) ;;
- [ajout de `mb_str_split()`](https://wiki.php.net/rfc/mb_str_split) pour couper une chaîne de caractères sur plusieurs octets, proposé par Rumi Legal ([P](https://github.com/php/php-src/pull/3715) [R](https://github.com/php/php-src/pull/3808)) ;
- [réflectivité pour les références](https://wiki.php.net/rfc/reference_reflection) proposée par Nikita Popov ([PR](https://github.com/php/php-src/pull/3550 "Pull Request")) ;
- [nouveau mécanisme de sérialisation](https://wiki.php.net/rfc/custom_object_serialization), proposé par Nikita Popov ([PR](https://github.com/php/php-src/pull/3761)) ;
- [fin de la prise en charge du format](https://wiki.php.net/rfc/jit) [WDDX](https://fr.wikipedia.org/wiki/Web_Distributed_Data_eXchange), proposée par Dmitry Stogov et Zeev Suraski ([51 fichiers supprimés](http://git.php.net/?p=php-src.git;a=commit;h=6bbb18a0b6bef11222caaa55c00abdbcbb55d54b)).
# Réduction de la verbosité du langage #
## Null coalescing assignment operator ##
Cette nouveauté évite de dupliquer le nom de la variable de part et d’autre de l’opérateur d’affectation. Par exemple, les deux lignes suivantes ont le même comportement :
 
```php
$this->request->data['comments']['user_id'] = $this->request->data['comments']['user_id'] ?? 'value';
$this->request->data['comments']['user_id'] ??= 'value';
```
## Fonctions fléchées ##
Cette nouveauté a été définie dans cette [RFC](https://wiki.php.net/rfc/arrow_functions_v2). Elle vise, entre autres, à rendre l’usage du côté fonctionnel du langage plus agréable. Oui, oui, PHP a [quelques marges d’amélioration](https://apiumhub.com/tech-blog-barcelona/functional-php/) à ce niveau‐là !
 
Ici, il sera plus agréable de remplacer les bons vieux `foreach()` pour traiter les tableaux par des `array_map()` ou des `array_filter()`. Globalement ça s’inspire des fonctions fléchées du JavaScript.
 
```php
$double = array_map(fn($e) => 2 * $e, [1, 2, 3]);
$utilisateursMineurs = array_filter($users, fn(User $user) => $user->age < 18); ``` Nous pouvons noter la cohérence du langage entre les deux fonctionnalités, l’ordre d’appel entre le tableau et la méthode de retour n’est pas le même. # Évolution de la syntaxe # ## Séparateur d’unité ## Il est possible d’ajouter un séparateur d’unité pour les nombres afin de les rendre plus lisibles. Par exemple, `$milliard = 1000000000` pourra s’écrire `$milliard = 1_000_000_000`. En revanche, attention à l’utilisation, il y a des risques de ne pas affecter la bonne valeur. ## Les opérateurs ternaires imbriqués ne sont plus associés par la gauche ## PHP était un des rares langages à proposer une associativité des ternaires par la gauche. Et pour éviter aux développeurs de se prendre les pieds dans le tapis, elle disparaît. Le mieux étant tout de même d’éviter les ternaires imbriqués. # Un typage plus présent # Depuis la version 7.0, le typage est de plus en plus présent au sein du langage. Il est possible de typer les arguments et le type de retour d’une méthode. Dorénavant, il sera aussi possible de spécifier le type des attributs d’une classe. ```php class Sportif { private Sport $sport = 'cyclimse'; private Humain $humain; public function __construct(Humain $humain, Sport $sport) { $this->humain = $humain;
 $this->sport = $sport;
 }
 public function entrainer():void
 {
 $this->humain->ajouteEntrainement($this->sport);
 } 
```
 
Ces ajouts sur les types facilitent la compréhension du code. En revanche, sans contrainte, PHP a un typage dynamique, donc le code suivant n’a pas forcément un résultat intuitif :
 
```php
$somme = function (int $a, int $b): int {return $a + $b; };
echo $somme("1", 2.1); // affiche 3
```
En forçant une évaluation stricte des types en plaçant `declare(strict_types=1);` en début de fichier, le code déclenche une erreur sur le typage. Ainsi, le développeur est forcé à prêter plus attention aux arguments passés aux méthodes.
 
En PHP 8, s’ajouteront les [types unions](https://wiki.php.net/rfc/union_types_v2), et espérons qu’ils seront accompagnés par des énumérations.
# Améliorations des performances #
Comme à chaque fois depuis la version 7.0, les performances natives du langage s’améliorent. Il est actuellement un des langages interprétés les plus rapides. Il faut néanmoins relativiser, car un langage qui va vite c’est une chose, mais si du temps est perdu à attendre le retour d’une requête en base de données ou, pire, depuis le réseau, les gains côté PHP ne sont pas très utiles. C’est d’ailleurs une des raisons pour lesquelles le JIT ne sera pas activé par défaut en PHP 8.
## Foreign Function Interface ##
L’idée est ici de pouvoir appeler un programme en C depuis un script PHP, un peu à l’idée de ce qu’il est possible de faire en Python en écrivant du CPython.
 
Il sera possible d’écrire des choses du genre ([source](https://github.com/dstogov/php-ffi)) :
 
```php
$libc = FFI::cdef("
 int printf(const char *format, ...);
 const char * getenv(const char *);
 unsigned int time(unsigned int *);
 typedef unsigned int time_t;
 typedef unsigned int suseconds_t;
 struct timeval {
 time_t tv_sec;
 suseconds_t tv_usec;
 };
 struct timezone {
 int tz_minuteswest;
 int tz_dsttime;
 };
	int gettimeofday(struct timeval *tv, struct timezone *tz);
", "libc.so.6");
$libc->printf("Hello World from %s!\n", "PHP");
var_dump($libc->getenv("PATH"));
var_dump($libc->time(null));
$tv = $libc->new("struct timeval");
$tz = $libc->new("struct timezone");
$libc->gettimeofday(FFI::addr($tv), FFI::addr($tz));
var_dump($tv->tv_sec, $tv->tv_usec, $tz);
```
 
Cette fonctionnalité ouvre la possibilité d’effectuer des traitements qui habituellement ne se font pas en PHP. D’ailleurs, voici un [exemple d’utilisation](https://github.com/vdechenaux/PhpWebcam).
## Préchargement ##
L’idée est de charger des fichiers afin que PHP crée un « binaire ». En contre‐partie, la mise à jour du binaire devra attendre un prochain démarrage et le temps de démarrage sera un peu plus long. Ce préchargement est donc intéressant pour les fichiers qui évoluent rarement, globalement ceux du cadriciel. En fonction des projets, il peut être intéressant de ne précharger que les fichiers les plus utilisés, comme le montre [ce commentaire](https://github.com/composer/composer/issues/7777#issuecomment-440268416).
La suite ?
==========
P++, Bringing Peace to the Galaxy
----------------------------------
En août 2019, la communauté s’était posé la question sur la création d’une variante du PHP : [P++](https://wiki.php.net/pplusplus/faq) (c’est un nom temporaire et on peut aussi lire PHP++). L’idée était de nettoyer le langage de ses aspects pas toujours cohérents, mais conservés pour des raisons de compatibilité. Un peu comme pour le langage [Raku](https://fr.wikipedia.org/wiki/Raku_(langage_de_programmation)) créé initialement pour rendre le langage [Perl](https://fr.wikipedia.org/wiki/Perl_(langage)) plus accessible. Le moteur d’exécution de PHP pourrait alors interpréter indifféremment un PHP *Classic* `<?php ?>` et un P++ `<?p++ ?>`. Benjamin Eberlei [propose](https://beberlei.de/2019/08/14/pplusplus_is_a_bad_idea.html) d’utiliser `<?php declare(std=20); ?>`.
 
Un [sondage ouvert à tous](https://www.strawpoll.me/18448151) montre que 60 % des répondants souhaitent un PHP 8 rétrocompatible, et un petit 20 % pour passer à P++. Les mainteneurs se sont aussi exprimés lors d’un [sondage plus formel](https://wiki.php.net/rfc/p-plus-plus#vote), et P++ ne verra pas le jour, car trop d’énergie à investir sur deux langages, la fragmentation de la communauté PHP...
PHP 8
-----
En fin d’année prochaine, PHP 8 devrait débarquer avec quelques gros changements. Le plus important est, peut‐être, la [compilation à la volée](https://fr.wikipedia.org/wiki/Compilation_à_la_volée) (_JIT_) [proposée par Dmitry Stogov](https://wiki.php.net/rfc/jit).
 
En 2011, Facebook annonçait des performances incroyables avec [HHVM](https://en.wikipedia.org/wiki/HHVM), son implémentation d’un moteur d’exécution PHP exploitant la compilation à la volée. Mais cette technique pour optimiser l’exécution de PHP n’avait pas été retenue pour le moteur d’exécution de référence. Néanmoins, PHP 7 a pu bénéficier d’autres mécanismes pour améliorer ses performances, rattraper HHVM et susciter un regain d’intérêt pour PHP.
 
Aujourd’hui, près de dix ans plus tard, il ne reste plus beaucoup d’options pour continuer d’améliorer les performances de PHP. Bien que la compilation à la volée ne devrait pas beaucoup améliorer la performance du rendu des pages Web, cette technique apporte deux avantages :
 
* une très bonne approche pour l’utilisation de PHP dans du calcul intensif, et cela devrait permettre d’utiliser PHP dans des domaines où on ne le considérait pas comme une option ;
* permettre de basculer des pans entiers du code PHP par l’équivalent dans un langage plus proche du processeur (comme le langage C) lors de cette compilation à la volée.
 
Cette compilation à la volée a failli être [intégrée](https://github.com/zendtech/php-src/tree/jit-dynasm-7.4) dans PHP 7.4 en mode expérimental. Ce changement correspond au plus [grand _commit_](https://github.com/php/php-src/commit/9a06876072b9ccb023d4a14426ccb587f10882f3) de l’histoire de PHP.
 
La future version PHP 8 apportera également d’autres améliorations que nous aurons plaisir à partager dans un an...
2029
----
Utilisera‐t‐on PHP dans dix ans, en 2029 ?
 
D’après le site _W3Techs_, PHP est encore et toujours [le langage le plus utilisé](https://w3techs.com/technologies/overview/programming_language/all) côté serveur Web. Les statistiques sont mises à jour quotidiennement. Voici les chiffres lors de la rédaction de cette dépêche :
 
* 79 % PHP ;
* 11 % ASP.NET ;
*  5 % Java et Scala ;
*  3 % Ruby (vive _LinuxFr.org_) ;
*  2 % HTML (fichiers statiques) ;
*  1 % Python ;
*  1 % JavaScript.
 
Pour la méthodologie utilisée, lire les [explications fournies par _W3Techs_](https://w3techs.com/technologies).
 
Avec un zoom sur les [versions de PHP](https://w3techs.com/technologies/details/pl-php/all/all) :
 
* PHP 3 &emsp; 0,0x % &emsp; 😱 plus maintenu depuis 19 ans !
* PHP 4 &emsp; 0,5 % &emsp; 😵 plus maintenu depuis 11 ans !
* PHP 5 &emsp;58 % &emsp; 😮 plus maintenu depuis un an ;
* PHP 6 &emsp; 0 % &emsp; 🤐 version abandonnée, jamais sortie ;
* PHP 7 &emsp;42 % &emsp; 😀 version actuelle ;
* PHP 8 &emsp; 0 % &emsp; 🤩 sortie prévue dans un an.
</div><div class="naked_ctrl">
<form action="/index.cgi/contrast" method="get" name="gate">
<p><a href="http://altstyle.alfasado.net">AltStyle</a> によって変換されたページ <a href="https://linuxfr.org/news/php-7-4.md">(-&gt;オリジナル)</a>
/ <label>アドレス: <input type="text" name="naked_post_url" value="https://linuxfr.org/news/php-7-4.md" size="22" /></label> <label>モード: <select name="naked_post_mode">
<option value="default">デフォルト</option>
<option value="speech">音声ブラウザ</option>
<option value="ruby">ルビ付き</option>
<option value="contrast" selected="selected">配色反転</option>
<option value="larger-text">文字拡大</option>
<option value="mobile">モバイル</option>
</select>
<input type="submit" value="表示" />
</p>
</form>
</div>