IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

PHP 8.2.0 RC1 est disponible. Cette version apporte les propriétés "en lecture seule" aux classes
Et rend obsolètes les propriétés dynamiques

Le , par Stéphane le calme

19PARTAGES

12  0 
Depuis le 1er septembre, l'équipe responsable du développement de PHP a annoncé la disponibilité de PHP 8.2.0 RC1, conformément à son calendrier. La RC2 est attendue le 15 septembre. Il y en aura six au total, la sixième étant attendue le 10 novembre. PHP 8.2 sera en disponibilité générale le 24 novembre 2022

Savoir à quoi s’attendre peut vous aider à vous préparer à la dernière version de PHP. En vous renseignant sur les nouvelles fonctionnalités et celles obsolètes, vous pouvez comprendre comment la mise à jour peut affecter votre développement. Cette connaissance peut également vous aider à vous préparer pour la sortie éventuelle.

Dans cette optique, passons en revue les fonctionnalités, les améliorations de performances, les modifications et les dépréciations.

De PHP 8.0 à PHP 8.1

Il est important de savoir à quelles modifications s’attendre avant la mise à niveau.

PHP 8.0

PHP 8.0, sorti en novembre 2020, a apporté une poignée de fonctionnalités essentielles. En plus des améliorations de la syntaxe et des performances, la version comprenait :
  • Des arguments nommés
  • la syntaxe de correspondance
  • les types de syndicats
  • Promotion Propriété Constructeur
  • JIT (qui affecte la façon dont PHP exécute le code source)

Les arguments nommés permettent de passer des arguments à une fonction en fonction du nom du paramètre, plutôt que de la position du paramètre. Cela rend la signification de l'argument autodocumentée, rend les arguments indépendants de l'ordre et permet de sauter arbitrairement les valeurs par défaut.

Pour donner un exemple simple :

Code PHP : Sélectionner tout
1
2
3
4
5
//en utilisant des arguments de position:  
array_fill(0, 100, 50);  
 
//en utilisant des arguments nommés:  
array_fill(start_index: 0, num: 100, value: 50);

L'ordre dans lequel les arguments nommés sont passés n'a pas d'importance. L'exemple ci-dessus les passe dans le même ordre qu'ils sont déclarés dans la signature de la fonction, mais tout autre ordre est également possible.

PHP 8 introduit deux moteurs de compilation JIT (juste à temps/compilation à la volée). Le Tracing JIT, le plus prometteur des deux, montre environ trois 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.

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 ;
  • validation de méthode abstraite des traits ;
  • signature valide des méthodes magiques ;
  • reclassifications des avertissements du moteur ;
  • erreur fatale pour des signatures de méthodes incompatibles ;
  • l'opérateur @ ne silence plus les erreurs fatales ;
  • héritages avec les méthodes privées ;
  • type mixed ;
  • type de retour static ;
  • types pour les fonctions internes Discussion e-mail ;
  • objets opaques au lieu de ressources pour les extensions Curl, Gd, Sockets, OpenSSL, XMLWriter, et XML.

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.

Ainsi, dans PHP 7 vous aviez

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
switch (8.0) { 
  case '8.0': 
    $result = "Oh no!"; 
    break; 
  case 8.0: 
    $result = "This is what I expected"; 
    break; 
} 
echo $result; 
//> Oh no!

Et son équivalent en PHP 8

Code PHP : Sélectionner tout
1
2
3
4
5
echo match (8.0) { 
  '8.0' => "Oh no!", 
  8.0 => "This is what I expected", 
}; 
//> This is what I expected

PHP 8.1

Un an plus tard est arrivé PHP 8.1, la dernière version majeure de PHP. Cette mise à jour comprend des fonctionnalités importantes, telles que :
  • Types d’intersections
  • Propriétés en lecture seule
  • Énumérations
  • le type de retour never

Les énumérations ou « Enums » permettent à un développeur de définir un type personnalisé limité à l'une des valeurs possibles parmi un nombre discret. Cela peut être particulièrement utile lors de la définition d'un modèle de domaine, car cela permet de « rendre les états invalides non représentables ».

Les énumérations apparaissent dans de nombreux langages avec une variété de fonctionnalités différentes. En PHP, les Enums sont un type particulier d'objet. L'Enum lui-même est une classe et ses cas possibles sont tous des objets à instance unique de cette classe. Cela signifie que les cas Enum sont des objets valides et peuvent être utilisés partout où un objet peut être utilisé, y compris les vérifications de type.

L'exemple le plus populaire d'énumérations est le type booléen intégré, qui est un type énuméré avec les valeurs légales true et false. Les énumérations permettent aux développeurs de définir leurs propres énumérations arbitrairement robustes.

Dans PHP 8.1, les énumérations sont limitées aux « énumérations d'unités », c'est-à-dire aux énumérations qui sont elles-mêmes une valeur, plutôt qu'une simple syntaxe sophistiquée pour une constante primitive, et n'incluent pas d'informations associées supplémentaires. Cette capacité offre une prise en charge considérablement étendue de la modélisation des données, des définitions de types personnalisées et du comportement de style monade. Les énumérations permettent la technique de modélisation consistant à « rendre les états invalides non représentables », ce qui conduit à un code plus robuste avec moins de tests exhaustifs.

Les responsables du langage recommandent d'utiliser les énumérations au lieu d'un ensemble de constantes et d'obtenir ainsi une validation prête à l'emploi.

Par exemple, avant PHP 8.1, vous pouviez écrire :

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
class Status 
{ 
    const DRAFT = 'draft'; 
    const PUBLISHED = 'published'; 
    const ARCHIVED = 'archived'; 
} 
function acceptStatus(string $status) {...}

Ce code est optimisé en PHP 8.1 avec les énumérations :

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
enum Status 
{ 
    case Draft; 
    case Published; 
    case Archived; 
} 
function acceptStatus(Status $status) {...}

Propriétés en lecture seule readonly : Les objets valeur sont souvent immuables : les propriétés sont initialisées une fois dans le constructeur et ne doivent pas être modifiées par la suite. PHP n'a actuellement aucun moyen d'appliquer cette contrainte. L'alternative la plus proche consiste à déclarer la propriété private et à n'exposer qu'un getter public

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
9
class User { 
    public function __construct( 
        private string $name 
    ) {} 
 
    public function getName(): string { 
        return $this->name; 
    } 
}

Cela ne rend pas réellement la propriété en lecture seule, mais cela resserre la portée où une modification pourrait se produire sur une seule déclaration de classe. Malheureusement, cela nécessite l'utilisation d'un passe-partout getter, ce qui entraîne une moins bonne ergonomie.

La prise en charge des propriétés en lecture seule de première classe vous permet d'exposer directement les propriétés publiques en lecture seule, sans craindre que les invariants de classe puissent être rompus par une modification externe :

Code PHP : Sélectionner tout
1
2
3
4
5
class User { 
    public function __construct( 
        public readonly string $name 
    ) {} 
}

Aussi, cette proposition a été retenue : une propriété en lecture seule ne peut être initialisée qu'une seule fois, et uniquement à partir de la portée où elle a été déclarée. Toute autre affectation ou modification de la propriété entraînera une exception d'erreur.

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Test { 
    public readonly string $prop; 
 
    public function __construct(string $prop) { 
        // Legal initialization. 
        $this->prop = $prop; 
    } 
} 
 
$test = new Test("foobar"); 
// Legal read. 
var_dump($test->prop); // string(6) "foobar" 
 
// Illegal reassignment. It does not matter that the assigned value is the same. 
$test->prop = "foobar"; 
// Error: Cannot modify readonly property Test::$prop

La suite concerne PHP 8.2.

null, true et false en tant que types autonomes (Release Candidate)

PHP 8.2 ajoute trois nouveaux types — ou quelque chose qui y ressemble. Techniquement null, true et false pourraient être considérés comme des types valides en eux-mêmes. Des exemples courants sont les fonctions intégrées de PHP, où false est utilisé comme type de retour lorsqu'une erreur se produit. Par exemple dans file_get_contents:

Code PHP : Sélectionner tout
file_get_contents(/* … */): string|false

Avant PHP 8.2, vous pouviez déjà utiliser false avec d'autres types comme union ; mais maintenant, il peut également être utilisé comme type autonome :

Code PHP : Sélectionner tout
1
2
3
4
function alwaysFalse(): false
{
    return false;
}

Il en va de même pour true et null.

Classes en lecture seule (RFC)

Les propriétés en lecture seule ont été introduites dans PHP 8.1. Cette RFC s'appuie sur eux et ajoute du sucre syntaxique pour rendre toutes les propriétés de classe en lecture seule à la fois. Au lieu d'écrire ceci :

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
9
class Post
{
    public function __construct(
        public readonly string $title, 
        public readonly Author $author,
        public readonly string $body,
        public readonly DateTime $publishedAt,
    ) {}
}

Vous pouvez maintenant écrire ceci :

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
9
readonly class Post
{
    public function __construct(
        public string $title, 
        public Author $author,
        public string $body,
        public DateTime $publishedAt,
    ) {}
}

Fonctionnellement, rendre une classe en lecture seule est entièrement identique à rendre chaque propriété en lecture seule ; mais cela empêchera également l'ajout de propriétés dynamiques sur une classe*:

Code PHP : Sélectionner tout
1
2
3
$post = new Post(/* … */);
 
$post->unknown = 'wrong';
Citation Envoyé par Résultat
Uncaught Error: Cannot create dynamic property Post::$unknown
Déprécier les propriétés dynamiques (rfc)

En parlant de propriétés dynamiques : c'est un changement pour le mieux, mais cela fera un peu mal. Les propriétés dynamiques sont obsolètes en PHP 8.2 et lèveront une ErrorException en PHP 9.0. Que sont les propriétés dynamiques, demandez-vous*? Ce sont des propriétés qui ne sont pas présentes sur un objet, mais qui sont néanmoins définies ou obtenues :

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
class Post
{
    public string $title;
}
 
// …
 
$post->name = 'Name';

Gardez à l'esprit que les classes implémentant __get et __set fonctionneront toujours comme prévu :

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
class Post
{
    private array $properties = [];
 
    public function __set(string $name, mixed $value): void
    {
        $this->properties[$name] = $value;
    }
}
 
// …
 
$post->name = 'Name';

Il en va de même pour les objets de stdClass, ils continueront à prendre en charge les propriétés dynamiques.

Il est indéniable qu'il y a des développeurs qui se sont appuyés sur des propriétés dynamiques et qui ne sont pas satisfaits de ce changement. Mais l'équipe pense que ces développeurs gagneraient à approfondir l'analyse statique.

Et juste au cas où vous ne voudriez pas ces avertissements lors de la mise à niveau vers PHP 8.2, vous pouvez faire plusieurs choses.

Vous pouvez utiliser l'attribut #[AllowDynamicProperties] sur les classes qui doivent toujours autoriser ces propriétés :

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
9
#[AllowDynamicProperties]
class Post
{
    public string $title;
}
 
// …
 
$post->name = 'Name'; // All fine

Ou vous pouvez simplement désactiver les avertissements d'obsolescence. Cela n'est pas recommandé, car vous aurez des problèmes avec PHP 9.0, mais voici comment désactiver les avertissements de dépréciation en PHP :

Code PHP : Sélectionner tout
error_reporting(E_ALL ^ E_DEPRECATED);

Types de forme normale disjonctive (DNF pour Disjunctive Normal Form) en RFC

Les types DNF nous permettent de combiner les types d'union et d'intersection, en suivant une règle stricte*: lors de la combinaison de types d'union et d'intersection, les types d'intersection doivent être regroupés avec des crochets. En pratique, cela ressemble à ceci :

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
function generateSlug((HasTitle&HasId)|null $post) 
{
    if ($post === null) {
        return '';
    }
 
    return 
        strtolower($post->getTitle()) 
        . $post->getId();
}

Dans ce cas, (HasTitle&HasId)|null est le type DNF.

C'est un ajout intéressant, d'autant plus que cela signifie que nous pouvons désormais avoir des types d'intersection nullables, ce qui est probablement le cas d'utilisation le plus important pour cette fonctionnalité.

Constantes dans les traits (rfc)

Vous pouvez désormais utiliser des constantes dans les traits*:

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
9
trait Foo 
{
    public const CONSTANT = 1;
 
    public function bar(): int 
    {
        return self::CONSTANT;
    }
}

Vous ne pourrez pas accéder à la constante via le nom du trait, ni de l'extérieur du trait, ni de l'intérieur de celui-ci.

Code PHP : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
trait Foo 
{
    public const CONSTANT = 1;
 
    public function bar(): int 
    {
        return Foo::CONSTANT;
    }
}
 
Foo::CONSTANT;

Vous pouvez cependant accéder à la constante via la classe qui utilise le trait, étant donné qu'elle est publique*:

Code PHP : Sélectionner tout
1
2
3
4
5
6
class MyClass
{
    use Foo;
}
 
MyClass::CONSTANT; // 1

Ces quelques améliorations et corrections accompagnent la RC1 :

CLI*:
  • Implémenter un serveur Web intégré répondant sans corps à la requête HEAD sur une ressource statique.
  • Implémenter un serveur Web intégré répondant avec le statut HTTP 405 à la requête DELETE/PUT/PATCH sur une ressource statique.


Cœur:
  • Correction du bug GH-9323 (Crash dans ZEND_RETURN/GC/zend_call_function)
  • Correction du bogue GH-9227 (les points de fin et les espaces dans les noms de fichiers sont ignorés).
  • Correction du bug GH-9285 (les traits ne peuvent pas être utilisés dans les classes en lecture seule).
  • Correction du bogue GH-9186 (@strict-properties peut être contourné en utilisant la désérialisation).

Date:
  • Correction du bogue GH-9431 (DateTime :: getLastErrors() ne renvoyant pas false en l'absence d'erreurs/avertissements).


OpenSSL*:
  • Correction du bogue GH-9310 (SSL local_cert et local_pk ne respectent pas open_basedir).
  • Implémenter FR #76935 ("chacha20-poly1305" est un AEAD mais ne fonctionne pas comme AEAD).
  • Ajout de la fonction openssl_cipher_key_length.


Source : PHP

Voir aussi :

PHP 8 est disponible et s'accompagne d'optimisations et de nouvelles fonctionnalités, incluant entre autres les arguments nommés, les types d'union, l'opérateur nullsafe, la compilation JIT
PHP 8.1 est disponible. Cette version permet d'obtenir une référence à n'importe quelle fonction et apporte le type de retour never

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de selmanjo
Membre régulier https://www.developpez.com
Le 08/09/2022 à 15:45
J'ai bien aimé le " match " qu'on retrouve dans pas mal de langages
0  0