PHP 7.4, qui n’est autre que la dernière version de PHP antérieure à PHP 8, est sortie le 28 novembre dernier. Comme annoncé, cette version apporte une pléthore de nouvelles fonctionnalités, des ajouts de syntaxe, et des correctifs. Ce qui, une fois de plus, a permis d’améliorer les performances, la lisibilité et la maintenabilité du code.

Au risque de décevoir certains, il est quand même important de rappeler qu’il s’agit d’une version mineure. Il faudra certainement attendre PHP 8 pour voir des changements vraiment énormes ou radicaux. Néanmoins, les nouveautés que cette version nous propose parlent d’elles-mêmes. PHP 7.4 surprend. Quelles sont ces nouveautés ? D’abord, nous parlerons des nouvelles fonctionnalités, puis des dépréciations qu’apporte cette nouvelle version.

Les nouvelles fonctionnalités dans PHP 7.4

Les nouvelles fonctionnalités dans PHP 7.4 sont trop nombreuses pour qu’on puisse les aborder toutes ici. Pour cette raison, nous n’évoquerons que ceux qui ont permis un véritable boost de performance :

1- Prise en charge des propriétés typées

PHP 7 révolutionne en introduisant les Types scalaires et les Types de retour. Néanmoins, dans cette version, il n’était pas encore possible de déclarer des Types pour les propriétés de classe, obligeant les développeurs à utiliser les méthodes getter et setter pour appliquer des contrats de type. Cela nuisait considérablement aux performances. Le RFC Typed Properties 2.0 résout ce problème en rendant possible la prise en charge des déclarations de type de propriété de première classe. Voici comment ce RFC se présente :

class A
{
    public string $nom;

    public Foo $bar;
}

Voici un autre exemple plus plaisant (repris sur https://wiki.php.net/). Un code comme celui-ci :

class Example {
    // All types with the exception of "void" and "callable" are supported
    public int $scalarType;
    protected ClassName $classType;
    private ?ClassName $nullableClassType;

    // Types are also legal on static properties
    public static iterable $staticProp;

    // Types can also be used with the "var" notation
    var bool $flag;

    // Typed properties may have default values (more below)
    public string $str = "foo";
    public ?string $nullableStr = null;

// The type applies to all properties in one declaration
    public float $x, $y;
    // equivalent to:
    public float $x;
    public float $y;
}

Peut maintenant être écrit comme suit :

class User {
    public int $id;
    public string $name;

    public function __construct(int $id, string $name) {
        $this->id = $id;
        $this->name = $name;
    }
}

Comme on peut le constater, les propriétés typées simplifient prodigieusement le code. Sur un serveur web, cela se traduit par des pages web plus légères et donc plus rapides à charger. Pourtant, par le passé ce RFC a déjà fait l’objet d’une proposition, mais celle-ci a malheureusement été refusée par la communauté. Pour cause, il soulevait d’importantes inquiétudes comme la non-prise en charge des types de propriétés statiques et des références aux propriétés typées. Ce qui, bien sûr, n’est plus le cas avec cette nouvelle version, expliquant son approbation.

2- Fonctions Arrow

Grâce aux fonctions arrow, coder sur PHP n’a jamais été aussi plaisant. Le RFC Fonctions Arrow permet l’utilisation d’une syntaxe plus concise. Une fonction qui faisait avant plusieurs lignes peut maintenant être simplifiée en une seule.

Considérez l’exemple suivant :

array_map(function (User $user) {
    return $user->id;
}, $users)

Grâce à cette fonctionnalité, il peut être réécrit et simplifié comme suit :

array_map(fn(User $user) => $user->id, $users)

En gros, la nouvelle syntaxe améliore la maintenabilité et la visibilité du code.

D’autres choses à savoir sur les fonctions arrow :

  • Elles débutent obligatoirement par le mot clé
  • Elles ne peuvent avoir qu’une seule expression.
  • L’opérateur de propagation est également autorisé.
  • Les références sont autorisées (pour les arguments et pour les valeurs de retour).
  • Les variables de l’environnement parent y sont accessibles.
  • Pas de multiligne également, vu que l’objectif est de réduire la verbosité.

3- L’opérateur Spread dans l’expression de Array

Vous pouvez maintenant utiliser des opérateurs de propagation dans des tableaux. Ils sont plus rapides que array_merge et augmentent de ce fait les performances de PHP 7.4. Bien que PHP supporte les opérateurs de spread depuis PHP 5.6, ils sont maintenant également disponibles pour les expressions array.

Avant, pour décompresser un array, il fallait que celui-ci soit précédé de 3 points (…). Cette nouvelle fonctionnalité propose une écriture plus simple et surtout la définition de array, comme le montre l’exemple suivant :

function test(...$args) { var_dump($args); }

test(1, 2, 3);

Redéfinition :

$arr = [...$args];

L’opérateur Spread est plus performant que array_merge. D’abord, parce qu’il possède une structure de langage, alors que array_merge est une fonction. Mais aussi, l’optimisation du temps de compilation peut également être performante pour les arrays constants. Il est important de souligner que ça ne fonctionne que pour les tableaux aux clés numériques.

Avant :

array_merge (iterator_to_array ($ iter1), iterator_to_array ($ iter2))
Ou généraliser à tous les iterables
array_merge (
   is_array ($ iter1)? $ iter1: iterator_to_array ($ iter1),
   is_array ($ iter2)? $ iter2: iterator_to_array ($ iter2)
)

Après :

[ ...$iter1, ...$iter2 ]

4- Le Preloading (préchargement)

Le Preloading  est l’une des nouvelles fonctionnalités les plus importantes, car ’il apporte une nette amélioration de performances du code. Il repose pourtant sur un concept très simple. Si vous utilisez un framework, ses fichiers doivent être chargés et liés à chaque requête. Le Preloading permet au serveur de charger des fichiers PHP en mémoire au démarrage et de les mettre à disposition en permanence pour toutes les requêtes ultérieures. Les fichiers sont préchargés et donc mettront moins de temps pour s’afficher.

Pour que le Preloading fonctionne, vous devez commencer par indiquer au serveur les fichiers à charger. Mais attention, pour que les fichiers soient préchargés, leurs dépendances (interfaces, traits et classes parentes) doivent également être préchargées. Autrement, des erreurs apparaîtront. Vous pouvez aussi décider de précharger uniquement les « classes chaudes ». Ce sont les classes fréquemment utilisées dans votre base de code.

Les dépréciations dans PHP 7.4

Toute mise à jour apporte son lot de dépréciations. PHP 7.4 ne fait pas exception à cette règle. Les dépréciations pour cette nouvelle version sont nombreuses. Donc, assurez-vous de lire la liste officielle compilée par la communauté de PHP. Vous y verrez également la liste des fonctions déjà présentes dans la version antérieure à celle-ci, mais qui ont subi des modifications majeures. Voici néanmoins quelques changements apportés par PHP 7.4 :

  • L’imbrication d’opérateurs ternaires sans parenthèses explicites est déconseillée.
  • La syntaxe d’accès au tableau et au décalage de chaîne utilisant des accolades est obsolète.
  • La distribution (real) est obsolète, utilisez plutôt (float).
  • L’utilisation de « parent » dans une classe sans parent est obsolète, et jettera une erreur de compilation dans le futur.
  • La directive allow_url_include ini est obsolète.
  • L’importation de bibliothèques de types avec l’enregistrement des constantes sans distinction de casse est obsolète.
  • FILTER_SANITIZE_MAGIC_QUOTES est obsolète, utilisez FILTER_SANITIZE_ADD_SLASHES
  • Passer l’encodage en tant que 3ème paramètre à mb_strrpos () est déconseillé.
  • ldap_control_paged_result_response et ldap_control_paged_result sont obsolètes.
  • Les appels à ReflectionType :: __ toString () génèrent désormais un avis de désapprobation.
  • Les méthodes export () sur toutes les classes de Reflection sont obsolètes.
  • L’utilisation de array_key_exists () sur des objets est obsolète.
  • La fonction is_real () est obsolète, utilisez plutôt is_float ().
  • Les fonctions get_magic_quotes_gpc () et get_magic_quotes_runtime () sont obsolète.

Quel langage de programmation utilise nos serveurs web ?

PHP est le langage de programmation côté serveur le plus utilisé sur le Web. On l’utilise principalement pour produire des pages web dynamiques (via un serveur HTTP) et concevoir des applications telles que les plugins. C’est un outil incontournable, dans la mesure où aujourd’hui presque tous les sites web ne sont plus constitués de simples pages HTML. Cela va de soi que la majorité des serveurs web l’ont adopté. Chez EasyHoster, ils couplent ce moteur d’exécution avec le logiciel de serveur web Apache et les mettent régulièrement à jour pour jouir de leurs pleines capacités. C’est, entre autres, grâce à cela qu’ils arrivent à garantir une vitesse de chargement optimisée, que ce soit sur mobile ou sur ordinateur.

La version PHP 7.4 est sortie le 28 novembre 2019. Dès début octobre, ils ont lancé la mise à jour sur leurs serveurs. Ils n’ont pas perdu leur temps pour profiter de ce qu’elle a à offrir. C’était aussi une obligation professionnelle. Pour leurs solutions d’hébergement web, ils font le nécessaire pour vous offrir les meilleures performances possibles.