Que signifie PHP 7.4 pour vous?
PHP évolue continuellement et ils viennent de publier leur dernière mise à jour PHP 7.4, pleine de nouvelles fonctionnalités. Comme nous l'avons déjà prouvé dans les versions précédentes de PHP 7 - les performances et la vitesse continuent à progresser. Le
préchargement est l'une des nouvelles fonctionnalités les plus intéressantes. Il accélère l'exécution du script et introduit la possibilité d'avoir un code plus rapide et plus propre en raison des lignes de code communes simplifiées.
Les responsables de PHP ont pris en compte les commentaires et les demandes de leur public et y ont répondu sans problème. Depuis, ils ont constamment changé de code pour être plus intuitif et plus confortable pour basculer entre les langages de programmation.
PHP est utilisé dans plus de 78,9% de tous les sites Web. Selon
W3techs , les sites les plus populaires utilisant PHP sont Wikipedia, Pinterest et Facebook, pour n'en nommer que quelques-uns.
Si nous regardons explicitement les sites WordPress exécutant PHP, en comparant PHP 5 et 7, nous pouvons voir une augmentation de la vitesse double. Les sites Web propulsés par WordPress gagnent le plus en utilisant la dernière version PHP disponible.
Ce graphique illustre la vérité sur les sites Web utilisant activement PHP. Sont
40 millions. des sites Web en direct suffisamment pour attirer votre attention? Voilà combien utilisent PHP en ce moment. De plus, PHP 7.4 présente déjà de meilleurs résultats de test que PHP 7.3 avec des performances améliorées et d'autres améliorations de la qualité de vie.
Le graphique ci-dessous montre le
test de référence global sur les nouvelles et anciennes versions de PHP. Certains des critères testés étaient la facilité d'utilisation, la vitesse et les performances, entre autres.
Quoi de neuf dans PHP 7.4?
Depuis 2016, PHP7 publie sans faute des mises à jour annuelles. Chaque année, ils proposent de nouvelles fonctionnalités, des ajouts et la possibilité d'écrire un code plus propre qui rend le langage plus fiable et convivial pour ceux qui l'exécutent sur leurs sites Web.
Examinons et examinons de plus près certaines des modifications qui ont été apportées avec l'ajout de PHP 7.4. Pour une liste complète, consultez leur changelog
ici .
Préchargement
Parlons du code. Lorsque vous utilisez un framework ou des bibliothèques, ses fichiers doivent être chargés et liés à chaque demande. Le préchargement, c'est quand vous pouvez charger des frameworks et des bibliothèques dans OPCache. Il permet au serveur de charger les fichiers PHP et de les stocker en mémoire lors du démarrage et de les mettre à disposition pour toute demande future. Parlez de faire avancer les choses rapidement!
Le préchargement est exécuté par une directive
php.ini spécifique:
opcache.preload . Celui-ci a le compilateur de script PHP et s'exécute au démarrage du serveur. Il peut également être utilisé pour précharger plus de fichiers et choisir de les inclure ou de les compiler.
C'est génial. Cependant, si la source des fichiers préchargés est modifiée, le serveur doit être redémarré. Les fichiers préchargés restent également mis en cache dans la mémoire OPCache pour toujours.
Cependant, ces fichiers préchargés continueront d'être disponibles pour toute demande future au cas où vous auriez besoin de les réutiliser.
Opérateur d'étalement dans les expressions de tableau
À l'époque de la sortie de PHP 5.6, PHP a commencé à prendre en charge le déballage des arguments (opérateur de propagation), mais maintenant, avec 7.4, nous pouvons utiliser cette fonctionnalité avec une expression de tableau. Le décompactage d'arguments est une syntaxe pour décompresser des tableaux et des éléments transversaux dans des listes d'arguments. Et, pour ce faire, il suffit de l'ajouter par ... (3 points.) C'est tout.
Regardons cet exemple:
$animals = ['dog', 'cat']; $animalkingdom = ['lion', 'elephant', ...$animals, 'giraffe'];
Nous pouvons maintenant étendre un tableau de n'importe où dans un autre tableau, en utilisant simplement la syntaxe Spread Operator.
Voici un exemple plus long:
$num1 = [1, 2, 3]; $num2 = [...$num1];
Non seulement cela, mais vous pouvez également l'utiliser dans une fonction. Découvrez cet exemple:
function getNum() { return ['a', 'b']; } $num6 = [...getNum(), 'c'];
De plus, vous pouvez désormais décompresser des tableaux et des générateurs renvoyés par une fonction directement dans un nouveau tableau.
Un exemple de code ressemblerait à ceci:
function getAnimals(){ return ['dog', 'cat', 'elephant']; } $num1 = [...getAnimals(), 'lion', 'tiger', 'giraffe'];
Et avec PHP 7.4, il afficherait:
array(6) { [0]=> string(3) "dog" [1]=> string(3) "cat" [2]=> string(8) "elephant" [3]=> string(4) "lion" [4]=> string(5) "tiger" [5]=> string(7) "giraffe" }
Avec cette nouvelle expression de tableau, les opérateurs de diffusion devraient avoir des performances bien meilleures que la 7.3 array_merge. En effet, l'opérateur de propagation est une structure de langage tandis que array_merge est une fonction. Également parce que l'opérateur spread prend en charge les objets implémentant traversable et array_merge ne prend en charge que les tableaux.
Quelques points importants à noter, vous ne pouvez utiliser que des tableaux indexés car les clés de chaîne ne sont pas prises en charge. S'il est utilisé, une erreur récupérable apparaîtra à l'écran, une fois une clé de chaîne trouvée.
Un autre avantage glorieux de 7.4 est la suppression de array_merge. Dites adieu au redoutable changement d'index!
Par exemple, regardons cette fusion de tableaux à long terme ci-dessous:
$array = ['banana, 'orange']; $array[2] = 'orange'; $array[1] = 'apple'; //shifting var_dump($array); // prints array(3) { [0]=> string(6) "banana" [1]=> string(5) "apple" [2]=> string(6) "orange"
Un autre avantage de 7.4 est l'utilisation de la fonction générateur. Une fonction de générateur fonctionne comme une fonction normale, sauf qu'au lieu de renvoyer une valeur, une
fonction de générateur produit autant de valeurs que nécessaire.
Consultez l'exemple de code ci-dessous:
function generator() { for ($i = 3; $i <= 5; $i++) { yield $i; } } $num1 = [0, 1, 2, ...generator()];
Références faibles
Maintenant PHP 7.4 a une classe WeakReference, qui ne doit pas être confondue avec la classe
WeakRed ou l'extension
Weakref .
Les références faibles permettent au programmeur de rappeler une référence à un objet. C'est utile car cela n'empêche pas la destruction de l'objet. Ils sont utiles pour implémenter des structures de type cache.
WeakReference { public __construct ( void ) public static create ( object $referent ) : WeakReference public get ( void ) : ?object }
Paramètres contraires et retours covariants
Actuellement, PHP utilise principalement des types de paramètres et des types de retour invariants. Autrement dit, si une méthode a un paramètre ou un type de retour de X, le paramètre de sous-type ou le type de retour doit également être de type
X.Maintenant, avec PHP 7.4, il propose d'autoriser la
covariante (ordonnée du spécifique au générique) et la
contravariante (inversant l'ordre) sur les types de paramètres et de retour.
Voici un exemple des deux:
Exemple de type de retour covariant:
interface Factory { function make(): object; } class UserFactory implements Factory { function make(): User; }
Exemple de type de paramètre contraignant:
interface Concatable { function concat(Iterator $input); } class Collection implements Concatable {
Propriétés typées 2.0
Depuis PHP 5, les indications de type sont une fonctionnalité disponible vous permettant de spécifier le type de variable qui devrait être transmis à une fonction ou une classe. Dans les migrations PHP 7.2, l'ajout du type de données objet a donné l'espoir que plus serait disponible à l'avenir. L'avenir est maintenant.
Dans la nouvelle version 7.4, PHP est capable de prendre en charge la liste de types suivante:
bool, int, float, string, array, object, iterable, self, parent any class or interface name ?type // where "type" may be any of the above
Notez que le type
parent peut être utilisé dans les classes et n'a pas besoin d'avoir un parent cohérent avec le paramètre et le type de retour.
Notez également que
void et
callable ne sont pas pris en charge.
Le vide a été supprimé car il n'était pas utile et sa sémantique n'était pas claire;
Appelable , car son comportement dépend du contexte.
Voyons quelques exemples supplémentaires.
Voici une classe, écrite pour PHP 7.3:
class User { private $id; private $name; public function __construct(int $id, string $name) { $this->id = $id; $this->name = $name; } public function getId(): int { return $this->id; } public function setId(int $id): void { $this->id = $id; } public function getName(): string { return $this->name; } public function setName(string $name): void { $this->name = $name; } }
En PHP 7.4, sans sacrifier la sécurité des types, une classe peut désormais être écrite aussi simplement que:
class User { public int $id; public string $name; public function __construct(int $id, string $name) { $this->id = $id; $this->name = $name; } }
Voici quelques exemples de tous les types que 7.4 prend désormais en charge:
class Example { public int $scalarType; protected ClassName $classType; private ?ClassName $nullableClassType;
Fonctions fléchées 2.0
Les fonctions anonymes en PHP ont tendance à être longues et longues, même lorsqu'elles n'effectuent que des opérations simples. Cela est dû en partie à une grande quantité de passe-partout syntaxique et en partie à la nécessité d'importer manuellement les variables utilisées.
Cela rend le code qui utilise des fermetures simples déroutant à lire et encore plus difficile à comprendre.
Regardons un peu de code que vous utiliseriez avec PHP 7.3:
function array_values_from_keys($arr, $keys) { return array_map(function ($x) use ($arr) { return $arr[$x]; }, $keys); }
Maintenant, voici la syntaxe la plus concise de PHP 7.4:
function array_values_from_keys($arr, $keys) { return array_map(fn($x) => $arr[$x], $keys); }
Par conséquent, les fonctions fléchées ont maintenant cette forme simple:
fn(parameter_list) => expr
Ci-dessous, vous pouvez voir un exemple de deux fonctions $ fn1 (7.3) et $ fn2 (7.4) côte à côte. Ils ont le même résultat mais semblent différents:
$y = 1; $fn1 = fn($x) => $x + $y; $fn2 = function ($x) use ($y) { return $x + $y; };
Cela fonctionnera également si les fonctions fléchées sont imbriquées:
$z = 1; $fn = fn($x) => fn($y) => $x * $y + $z;
Ici, la fonction externe capture
$ z . Ensuite, la fonction interne capture également $ z à partir de la fonction externe. Avec 7.4, la portée externe peut devenir disponible dans la fonction interne. C'est quelque chose que 7.3 n'a pas pu faire.
La syntaxe de la fonction flèche permet une variété de fonctions telles que les variadiques, les valeurs par défaut, les types de paramètres et de retour, ainsi que le passage et le retour par référence. Tout en gardant un look propre et lisible. Vous trouverez ci-dessous toutes les fonctions de flèche valides désormais disponibles:
fn(array $x) => $x; fn(): int => $x; fn($x = 42) => $x; fn(&$x) => $x; fn&($x) => $x; fn($x, ...$rest) => $rest;
Une chose à noter est que les fonctions fléchées ont la priorité la plus faible. Voir l'exemple:
fn($x) => $x + $y
Dépréciations
Il y a beaucoup de dépréciations avec la fusion à 7.4. La liste suivante est un bref aperçu des fonctions ciblées pour la dépréciation. Vous pouvez trouver une explication plus détaillée
ici :
- Le vrai type
- L'héritage de Magic Quotes
- array_key_exists () avec des objets
- Filtre FILTER_SANITIZE_MAGIC_QUOTES
- Méthodes d' exportation () de réflexion
- mb_strrpos () avec encodage comme 3e argument
- mélange d'ordre des paramètres implode ()
- Dissocier $ this des fermetures non statiques
- fonction hebrevc ()
- Fonction convert_cyr_string ()
- Fonction money_format ()
- Fonction ezmlm_hash ()
- r fonction estore_include_path ()
- allow_url_include ini directiv
Certains sont importants à noter sont les obsolescences en deux étapes suivantes.
Modification de la priorité d'un opérateur de concaténation
Actuellement, la priorité des opérateurs «.», «+» Et «-» sont toutes égales. Toute combinaison de ces opérateurs sera simplement résolue de gauche à droite.
Regardons ce code en PHP 7.3:
echo "sum: " . $a + $b;
Avec PHP 7.4, '+' et '-' auraient priorité sur '.' de sorte que les ajouts et les soustractions seraient toujours effectués avant la chaîne. Cela ressemblerait à ceci:
echo "sum: " . $a + $b;
Cette proposition en deux étapes vise à être moins sujette aux erreurs et plus instinctive. PHP 7.4 en est actuellement à la première étape avec un avis de dépréciation des expressions non parenthèses de '+', '-' et '.' En attendant le vote / changement final qui se passe en PHP 8.
Opérateur ternaire associatif gauche
Contrairement à la plupart des autres langages, l'opérateur ternaire en PHP est associatif à gauche plutôt qu'à droite. Non seulement il est rare, mais il est également déroutant pour les programmeurs qui basculent entre différentes langues. PHP 7.4 propose de supprimer l'associativité de gauche et nécessite plutôt l'utilisation de parenthèses.
Jetons un œil au code ci-dessous:
return $a == 1 ? 'one' : $a == 2 ? 'two' : $a == 3 ? 'three' : $a == 4 ? 'four' : 'other';
Dans la plupart des autres langues, il serait interprété comme:
return $a == 1 ? 'one' : ($a == 2 ? 'two' : ($a == 3 ? 'three' : ($a == 4 ? 'four' : 'other')))
En PHP, il est plutôt interprété comme:
return ((($a == 1 ? 'one' : $a == 2) ? 'two' : $a == 3) ? 'three' : $a == 4) ? 'four' : 'other';
Cela peut conduire à des erreurs, car ce n'est généralement pas ce qui était prévu.
Grâce à une proposition distincte en deux étapes, PHP 7.4 a implémenté l'utilisation explicite de parenthèses comme avertissement de dépréciation et, espérons-le, exécutera une erreur d'exécution de compilation dans les futures versions.
Conclusion
Juste à temps pour les vacances, PHP 7.4 apporte de nouvelles fonctionnalités et des améliorations de qualité de vie pour tous les développeurs PHP.
Les sites Web WordPress bénéficieront certainement de ces améliorations et leurs utilisateurs peuvent s'attendre à des temps d'exécution plus rapides et à une utilisation moindre de la mémoire lorsqu'ils utilisent PHP 7.4 par rapport aux versions précédentes.
Avec l'ajout de déclarations de type de propriété et d'indices de type de première classe, de fonctions de fusion de flèches et d'une vitesse ridiculement meilleure, le 7.4 améliorera sûrement la vitesse et la qualité de votre flux de travail.