PHP 8.2 est disponible en bta 2. Cette version propose null, true et false en tant que types autonomes ainsi que des constantes dans les traits

PHP 8.2 est disponible en bta 2. Cette version propose null, true et false en tant que types autonomes ainsi que des constantes dans les traits


Depuis le 4 aot, la bta 2 de PHP 8.2 est disponible. La bta 3 est attendue pour le 18 aot et une srie de 6 RC va dbuter le 1er septembre pour s’achever le 10 novembre. PHP 8.2 sera en disponibilit gnrale le 24 novembre 2022.

Savoir quoi sattendre peut vous aider vous prparer la dernire version de PHP. En vous renseignant sur les nouvelles fonctionnalits et celles obsoltes, vous pouvez comprendre comment la mise jour peut affecter votre dveloppement. Cette connaissance peut galement vous aider vous prparer pour la sortie ventuelle.

Dans cette optique, passons en revue les fonctionnalits, les amliorations de performances, les modifications et les dprciations.

De PHP 8.0 PHP 8.1

Il est important de savoir quelles modifications sattendre avant la mise niveau.

PHP 8.0

PHP 8.0, sorti en novembre 2020, a apport une poigne de fonctionnalits essentielles. En plus des amliorations de la syntaxe et des performances, la version comprenait :

  • Des arguments nomms
  • la syntaxe de correspondance
  • les types de syndicats
  • Promotion Proprit Constructeur
  • JIT (qui affecte la faon dont PHP excute le code source)

Les arguments nomms permettent de passer des arguments une fonction en fonction du nom du paramtre, plutt que de la position du paramtre. Cela rend la signification de l’argument autodocumente, rend les arguments indpendants de l’ordre et permet de sauter arbitrairement les valeurs par dfaut.

Pour donner un exemple simple :

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 nomms sont passs n'a pas d'importance. L'exemple ci-dessus les passe dans le mme ordre qu'ils sont dclars 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 vole). Le Tracing JIT, le plus prometteur des deux, montre environ trois fois plus de performances sur des benchmarks synthtiques et 1,5-2 fois plus de performances sur certaines applications longue dure d'excution. Gnralement les performances des applications sont identiques PHP 7.4.

Amlioration du systme de typage et de la gestion d'erreur

  • vrification de type plus svre pour les oprateurs arithmtiques et bit bit ;
  • validation de mthode abstraite des traits ;
  • signature valide des mthodes magiques ;
  • reclassifications des avertissements du moteur ;
  • erreur fatale pour des signatures de mthodes incompatibles ;
  • l'oprateur @ ne silence plus les erreurs fatales ;
  • hritages avec les mthodes prives ;
  • 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 fonctionnalits suivantes :

  • Match est une expression, signifiant que son rsultat 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 dclaration break ;
  • Match fait des comparaisons strictes.

Ainsi, dans PHP 7 vous aviez

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

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 dernire version majeure de PHP. Cette mise jour comprend des fonctionnalits importantes, telles que :

  • Types dintersections
  • Proprits en lecture seule
  • numrations
  • le type de retour never

Les numrations ou Enums permettent un dveloppeur de dfinir un type personnalis limit l'une des valeurs possibles parmi un nombre discret. Cela peut tre particulirement utile lors de la dfinition d'un modle de domaine, car cela permet de rendre les tats invalides non reprsentables .

Les numrations apparaissent dans de nombreux langages avec une varit de fonctionnalits diffrentes. En PHP, les Enums sont un type particulier d'objet. L'Enum lui-mme 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 utiliss partout o un objet peut tre utilis, y compris les vrifications de type.

L'exemple le plus populaire d'numrations est le type boolen intgr, qui est un type numr avec les valeurs lgales true et false. Les numrations permettent aux dveloppeurs de dfinir leurs propres numrations arbitrairement robustes.

Dans PHP 8.1, les numrations sont limites aux numrations d'units , c'est--dire aux numrations qui sont elles-mmes une valeur, plutt qu'une simple syntaxe sophistique pour une constante primitive, et n'incluent pas d'informations associes supplmentaires. Cette capacit offre une prise en charge considrablement tendue de la modlisation des donnes, des dfinitions de types personnalises et du comportement de style monade. Les numrations permettent la technique de modlisation consistant rendre les tats invalides non reprsentables , ce qui conduit un code plus robuste avec moins de tests exhaustifs.

Les responsables du langage recommandent d'utiliser les numrations au lieu d'un ensemble de constantes et d'obtenir ainsi une validation prte l'emploi.

Par exemple, avant PHP 8.1, vous pouviez crire :

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 numrations :

1
2
3
4
5
6
7

enum Status 
{ 
    case Draft; 
    case Published; 
    case Archived; 
} 
function acceptStatus(Status $status) {...}

Proprits en lecture seule readonly : Les objets valeur sont souvent immuables : les proprits sont initialises une fois dans le constructeur et ne doivent pas tre modifies par la suite. PHP n'a actuellement aucun moyen d'appliquer cette contrainte. L'alternative la plus proche consiste dclarer la proprit private et n'exposer qu'un getter public

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 rellement la proprit en lecture seule, mais cela resserre la porte o une modification pourrait se produire sur une seule dclaration de classe. Malheureusement, cela ncessite l'utilisation d'un passe-partout getter, ce qui entrane une moins bonne ergonomie.

La prise en charge des proprits en lecture seule de premire classe vous permet d'exposer directement les proprits publiques en lecture seule, sans craindre que les invariants de classe puissent tre rompus par une modification externe :

1
2
3
4
5

class User { 
    public function __construct( 
        public readonly string $name 
    ) {} 
}

Aussi, cette proposition a t retenue : une proprit en lecture seule ne peut tre initialise qu'une seule fois, et uniquement partir de la porte o elle a t dclare. Toute autre affectation ou modification de la proprit entranera une exception d'erreur.

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 considrs comme des types valides en eux-mmes. Des exemples courants sont les fonctions intgres de PHP, o false est utilis comme type de retour lorsqu'une erreur se produit. Par exemple dans file_get_contents*:

file_get_contents(/* … */): string|false

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

1
2
3
4

function alwaysFalse(): false
{
    return false;
}

Il en va de mme pour true et null.

Classes en lecture seule (RFC)

Les proprits 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 proprits de classe en lecture seule la fois. Au lieu d'crire ceci :

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 :

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 entirement identique rendre chaque proprit en lecture seule ; mais cela empchera galement l'ajout de proprits dynamiques sur une classe*:

1
2
3

$post = new Post(/* … */);
 
$post->unknown = 'wrong';
Citation Envoy par Rsultat

Uncaught Error: Cannot create dynamic property Post::$unknown

Dprcier les proprits dynamiques (rfc)

En parlant de proprits dynamiques*: c'est un changement pour le mieux, mais cela fera un peu mal. Les proprits dynamiques sont obsoltes en PHP 8.2 et lveront une ErrorException en PHP 9.0. Que sont les proprits dynamiques, demandez-vous*? Ce sont des proprits qui ne sont pas prsentes sur un objet, mais qui sont nanmoins dfinies ou obtenues*:

1
2
3
4
5
6
7
8

class Post
{
    public string $title;
}
 
// …
 
$post->name = 'Name';

Gardez l'esprit que les classes implmentant __get et __set fonctionneront toujours comme prvu*:

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 mme pour les objets de stdClass, ils continueront prendre en charge les proprits dynamiques.

Il est indniable qu'il y a des dveloppeurs qui se sont appuys sur des proprits dynamiques et qui ne sont pas satisfaits de ce changement. Mais l'quipe pense que ces dveloppeurs 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 proprits*:

1
2
3
4
5
6
7
8
9

#[AllowDynamicProperties]
class Post
{
    public string $title;
}
 
// …
 
$post->name = 'Name'; // All fine

Ou vous pouvez simplement dsactiver les avertissements d'obsolescence. Cela n'est pas recommand, car vous aurez des problmes avec PHP 9.0, mais voici comment dsactiver les avertissements de dprciation en PHP :

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 rgle stricte*: lors de la combinaison de types d'union et d'intersection, les types d'intersection doivent tre regroups avec des crochets. En pratique, cela ressemble ceci :

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 intressant, d'autant plus que cela signifie que nous pouvons dsormais 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 dsormais utiliser des constantes dans les traits*:

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 accder la constante via le nom du trait, ni de l'extrieur du trait, ni de l'intrieur de celui-ci.

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 accder la constante via la classe qui utilise le trait, tant donn qu'elle est publique*:

1
2
3
4
5
6

class MyClass
{
    use Foo;
}
 
MyClass::CONSTANT; // 1

Source : PHP

Voir aussi :

PHP 8 est disponible et s'accompagne d'optimisations et de nouvelles fonctionnalits, incluant entre autres les arguments nomms, les types d'union, l'oprateur nullsafe, la compilation JIT

PHP 8.1 est disponible. Cette version permet d'obtenir une rfrence n'importe quelle fonction et apporte le type de retour never

Leave a Comment

Your email address will not be published.