PHP 8.4.2 Released!
    ¡Lanzado!
    PHP 8.2 es una actualización importante del lenguaje PHP.
    Contiene muchas características nuevas, incluidas clases de solo lectura, null, false y true como tipos independientes, propiedades dinámicas en desuso, mejoras de rendimiento y más.
    ¡Actualiza a PHP 8.2 ahora!

    Clases de solo lectura 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;
    }
    }

    Tipos de forma normal disyuntiva (DNF) 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;
    }
    }
    Los tipos DNF nos permiten combinar unión y intersección de tipos, siguiendo una regla estricta: al combinar tipos de unión e intersección, los tipos de intersección deben agruparse con corchetes.

    Permitir null, false y true como tipos independientes 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 { /* ... */ *}
    }

    Nueva extensión "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();
    }

    La extensión "random" proporciona una nueva API orientada a objetos para la generación de números aleatorios. En lugar de depender de un generador de números aleatorios (RNG) globalmente sembrado utilizando el algoritmo Mersenne Twister, la API orientada a objetos proporciona varias clases ("Engine") que proporcionan acceso a algoritmos modernos que almacenan su estado dentro de objetos para permitir múltiples secuencias sembrables independientes.

    La clase \Random\Randomizer proporciona una interfaz de alto nivel para utilizar la aleatoriedad del motor para generar un número entero aleatorio, para mezclar un array o cadena, para seleccionar claves de array aleatorias y más.

    Constantes en rasgos 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
    No se puede acceder a la constante a través del nombre del rasgo, pero se puede acceder a la constante a través de la clase que utiliza el rasgo.

    Deprecar propiedades dinámicas 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

    La creación de propiedades dinámicas está en desuso para ayudar a evitar errores y errores tipográficos, a menos que la clase opte por usar el atributo #[\AllowDynamicProperties]. stdClass permite propiedades dinámicas.

    El uso de los métodos mágicos __get/__set no se ve afectado por este cambio.

    Nuevas clases, interfaces y funciones

    Deprecaciones y cambios de compatibilidad hacia atrás

    Mejor rendimiento, mejor sintaxis, mayor seguridad en los tipos.

    ¡Actualiza a PHP 8.2 ahora!

    Para descargar el código fuente de PHP 8.2, por favor visite la página de descargas. Los binarios de Windows se pueden encontrar en el sitio de PHP para Windows. La lista de cambios está registrada en el ChangeLog.

    La guía de migración está disponible en el Manual de PHP. Por favor, consulte la guía para obtener una lista detallada de las nuevas características y cambios incompatibles con versiones anteriores.

    To Top