PHP 8.4.2 Released!
    Released!
    PHP 8.2 est une mise à jour majeure du langage PHP.
    Elle contient beaucoup de nouvelles fonctionnalités et d'optimisations, incluant les classes en lecture seule, les types "stand-alone" null, false, et true, les propriétés dynamiques désormais obsolètes, et plus encore.
    Migrer vers PHP 8.2 maintenant!

    Classes en lecture seule RFC Doc

    PHP < 8.2
    class BlogData
    {
    public readonly     string $title;

    public readonly     Status $status;

    public function     __construct(string $title, Status $status)
    {
    $this->title = $title;
    $this->status = $status;
    }
    }
    PHP 8.2
    readonly class BlogData
    {
    public     string $title;

    public     Status $status;

    public function     __construct(string $title, Status $status)
    {
    $this->title = $title;
    $this->status = $status;
    }
    }

    Types FDN (forme normale disjonctive) RFC Doc

    PHP < 8.2
    class Foo {
    public function     bar(mixed $entity) {
    if (((    $entity instanceof A) && ($entity instanceof B)) || ($entity === null)) {
    return     $entity;
    }

    throw new     Exception('Invalid entity');
    }
    }
    PHP 8.2
    class Foo {
    public function     bar((A&B)|null $entity) {
    return     $entity;
    }
    }
    Les types FDN permettent de combiner des types union et intersection, en suivant une règle stricte: lorsque des types union et intersection sont combinés, les types intersection doivent être groupés entre parenthèses.

    Permettre null, false, et true comme types stand-alone RFC RFC

    PHP < 8.2
    class Falsy
    {
    public function     almostFalse(): bool { /* ... */ *}

    public function     almostTrue(): bool { /* ... */ *}

    public function     almostNull(): string|null { /* ... */ *}
    }
    PHP 8.2
    class Falsy
    {
    public function     alwaysFalse(): false { /* ... */ *}

    public function     alwaysTrue(): true { /* ... */ *}

    public function     alwaysNull(): null { /* ... */ *}
    }

    Nouvelle extension "Random" RFC RFC Doc

    PHP 8.2
    use Random\Engine\Xoshiro256StarStar;
    use     Random\Randomizer;

    $blueprintRng = new Xoshiro256StarStar(
    hash('sha256', "Example seed that is converted to a 256 Bit string via SHA-256", true)
    );

    $fibers = [];
    for (    $i = 0; $i < 8; $i++) {
    $fiberRng = clone $blueprintRng;
    // Xoshiro256**'s 'jump()' method moves the blueprint ahead 2**128 steps, as if calling
    // 'generate()' 2**128 times, giving the Fiber 2**128 unique values without needing to reseed.
    $blueprintRng->jump();

    $fibers[] = new Fiber(function () use ($fiberRng, $i): void {
    $randomizer = new Randomizer($fiberRng);

    echo     "{$i}: " . $randomizer->getInt(0, 100), PHP_EOL;
    });
    }

    // The randomizer will use a CSPRNG by default.
    $randomizer = new Randomizer();

    // Even though the fibers execute in a random order, they will print the same value
    // each time, because each has its own unique instance of the RNG.
    $fibers = $randomizer->shuffleArray($fibers);
    foreach (    $fibers as $fiber) {
    $fiber->start();
    }

    L'extension "random" fournit une nouvelle API orientée objet de génération de nombres aléatoires. Plutôt que de reposer sur un générateur de nombres aléatoires (utilisant l'algorithme Mersenne Twister) globalement initialisé, l'API orientée objet offre plusieurs classes permettant d'accéder à des algorithmes modernes stockant leur état au sein des objets, afin de fournir des séquences d'initialisations bien distinctes.

    La classe \Random\Randomizer fournit une interface de haut niveau permettant, par exemple, de générer un entier aléatoire, mélanger un tableau ou une chaine de caractère, et plus encore.

    Constantes dans les traits RFC Doc

    PHP 8.2
    trait Foo
    {
    public const     CONSTANT = 1;
    }

    class     Bar
    {
    use     Foo;
    }

    var_dump(Bar::CONSTANT); // 1
    var_dump(Foo::CONSTANT); // Error
    Il n'est pas possible d'accéder à une constante par le nom du trait, mais il est cependant possible d'y accéder par la classe utilisant ce trait.

    Propriétés dynamiques désormais obsolètes RFC Doc

    PHP < 8.2
    class User
    {
    public     $name;
    }

    $user = new User();
    $user->last_name = 'Doe';

    $user = new stdClass();
    $user->last_name = 'Doe';
    PHP 8.2
    class User
    {
    public     $name;
    }

    $user = new User();
    $user->last_name = 'Doe'; // Deprecated notice

    $user = new stdClass();
    $user->last_name = 'Doe'; // Still allowed

    Afin d'éviter des erreurs, la création des propriétés dynamiques est obsolète, sauf si la classe contient l'attribut #[\AllowDynamicProperties]. stdClass autorise les propriétés dynamiques.

    L'utilisation des méthodes magiques __get/__set n'est pas affectée par ce changement..

    Nouvelles classes, interfaces, et fonctions

    Obsolescence et changements non retrocompatibles

    Meilleures performances, meilleure syntaxe et amélioration de la sureté du typage.

    Migrer vers PHP 8.2 maintenant!

    Pour le téléchargement des sources de PHP 8.2 veuillez visiter la page de téléchargement page. Les binaires Windows peuvent être trouvés sur le site de PHP Pour Windows. La liste des changements est disponible dans le ChangeLog.

    Le guide de migration est disponible dans le manuel PHP. Veuillez le consulter pour une liste détaillée des nouvelles fonctionnalités et changements non rétrocompatibles.

    To Top