PHP 8.3.4 Released!
Released!
PHP 8.0 est une mise à jour majeure du langage PHP.
Elle contient beaucoup de nouvelles fonctionnalités et d'optimisations, incluant les arguments nommés, les types d'union, attributs, promotion de propriété de constructeur, l'expression match, l'opérateur nullsafe, JIT (Compilation à la Volée), et des améliorations dans le système de typage, la gestion d'erreur, et de cohérence.

Arguments nommés RFC

PHP 7
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
PHP 8
htmlspecialchars($string, double_encode: false);
  • Spécifiez uniquement les paramètres requis, omettant ceux optionnels.
  • Les arguments sont indépendants de l'ordre et auto-documentés.

Attributs RFC Doc

PHP 7
/**
* @Route("/api/posts/{id}", methods={"GET", "HEAD"})
*/
class User
{
PHP 8
#[Route("/api/posts/{id}", methods: ["GET", "HEAD"])]
class
User
{

Au lieux d'annotations PHPDoc, vous pouvez désormais utiliser les métadonnées structurés avec la syntaxe native de PHP.

Promotion de propriétés de constructeur RFC Doc

PHP 7
class Point {
public
float $x;
public
float $y;
public
float $z;

public function
__construct(
float $x = 0.0,
float $y = 0.0,
float $z = 0.0
) {
$this->x = $x;
$this->y = $y;
$this->z = $z;
}
}
PHP 8
class Point {
public function
__construct(
public
float $x = 0.0,
public
float $y = 0.0,
public
float $z = 0.0,
) {}
}

Moins de code redondant pour définir et initialiser les propriétés.

Types d'union RFC Doc

PHP 7
class Number {
/** @var int|float */
private $number;

/**
* @param float|int $number
*/
public function __construct($number) {
$this->number = $number;
}
}

new
Number('NaN'); // Ok
PHP 8
class Number {
public function
__construct(
private
int|float $number
) {}
}

new
Number('NaN'); // TypeError

Au lieu d'annotation PHPDoc pour une combinaison de type, vous pouvez utiliser les déclarations de types d'union native qui sont validées lors de l'exécution.

Expression match RFC Doc

PHP 7
switch (8.0) {
case
'8.0':
$result = "Oh no!";
break;
case
8.0:
$result = "This is what I expected";
break;
}
echo
$result;
//> Oh no!
PHP 8
echo match (8.0) {
'8.0' => "Oh no!",
8.0 => "This is what I expected",
};
//> This is what I expected

La nouvelle instruction match est similaire à switch et a les fonctionnalités suivantes :

  • Match est une expression, signifiant que son résultat peut être enregistré dans une variable ou retourné.
  • Les branches de match supportent uniquement les expressions d'une seule ligne, et n'a pas besoin d'une déclaration break;.
  • Match fait des comparaisons strictes.

Opérateur Nullsafe RFC

PHP 7
$country = null;

if (
$session !== null) {
$user = $session->user;

if (
$user !== null) {
$address = $user->getAddress();

if (
$address !== null) {
$country = $address->country;
}
}
}
PHP 8
$country = $session?->user?->getAddress()?->country;

Au lieu de faire des vérifications conditionnelles de null, vous pouvez utiliser une chaîne d'appel avec le nouvel opérateur nullsafe. Qui lorsque l'évaluation d'un élément de la chaîne échoue, l'exécution de la chaîne complète est terminée et la chaîne entière évalue à null.

Comparaisons entre les chaînes de caractères et les nombres plus saines RFC

PHP 7
0 == 'foobar' // true
PHP 8
0 == 'foobar' // false

Lors de la comparaison avec une chaîne numérique, PHP 8 utilise une comparaison de nombre. Sinon, il convertit le nombre à une chaîne de caractères et utilise une comparaison de chaîne de caractères.

Erreurs de type cohérent pour les fonctions internes RFC

PHP 7
strlen([]); // Warning: strlen() expects parameter 1 to be string, array given

array_chunk([], -1); // Warning: array_chunk(): Size parameter expected to be greater than 0
PHP 8
strlen([]); // TypeError: strlen(): Argument #1 ($str) must be of type string, array given

array_chunk([], -1); // ValueError: array_chunk(): Argument #2 ($length) must be greater than 0

La plupart des fonctions internes lancent désormais une exception Error si la validation du paramètre échoue.

Compilation Juste-à-Temps (JIT)

PHP 8 introduit deux moteurs de compilation JIT (juste à temps/compilation à la volée). Le Tracing JIT, le plus prometteur des deux, montre environ 3 fois plus de performances sur des benchmarks synthétiques et 1,5-2 fois plus de performances sur certaines applications à longue durée d'exécution. Généralement les performances des applications sont identiques à PHP 7.4.

Contribution relative du JIT à la performance de PHP 8

Just-In-Time compilation

Amélioration du système de typage et de la gestion d'erreur

  • Vérification de type plus sévère pour les opérateurs arithmétiques et bit à bit RFC
  • Validation de méthode abstraite des traits RFC
  • Signature valide des méthodes magiques RFC
  • Reclassifications des avertissements du moteur RFC
  • Erreur fatale pour des signatures de méthodes incompatibles RFC
  • L'opérateur @ ne silence plus les erreurs fatales.
  • Héritages avec les méthodes privées RFC
  • Type mixed RFC
  • Type de retour static RFC
  • Types pour les fonctions internes Discussion e-mail
  • Objets opaques au lieu de ressources pour les extensions Curl, Gd, Sockets, OpenSSL, XMLWriter, et XML

Autres ajustements de syntaxe et améliorations

  • Autorisation des virgules trainantes dans les listes de paramètres RFC et dans les listes des use d'une fermeture RFC
  • Les catchs non capturant RFC
  • Ajustement de la Syntaxe des Variables RFC
  • Traite les noms des espaces de nom comme un seul token RFC
  • Throw est désormais une expression RFC
  • Autorisation de ::class sur les objets RFC

Nouvelles Classes, Interfaces, et Fonctions

To Top