¿Qué hay de nuevo en PHP 8?

El 26 de Noviembre de 2020 salió la nueva versión de PHP 8 que nos trae bastantes novedades interesantes y en está publicación te cuento cuáles son; revisamos también algunos ejemplos y que futuro nos espera con PHP.

PHP 8 además de traer mejoras de seguridad y performance con JIT(Just in Time), está lleno de nuevos features de sintaxis que los desarrolladores apreciarán. Esperemos que la migración a está nueva versión no se complique, pero al final del día la talacha se tiene que hacer, además aún tendremos soporte de la versión 7.4 de PHP hasta Noviembre del 2022, esto porque cada versión de PHP tiene un ciclo de vida de 2 años durante el cual se corrigen los errores y un año adicional donde se corrigen los problemas de seguridad.

Funciones deprecadas

Algunas de las funciones que fueron deprecadas de php 7.4 a php 8.0 son:

• La variable $php_errormsg
• La función create_function()
• La directiva ini mbstring.func_overload
• El tipo real
• La directiva ini allow_url_include
• La función restore_include_path()
• La fución each()

Null safe operator

En vez de verificar condiciones nulas, tu puedes utilizar una cadena de llamadas con el nuevo operador nullsafe. Cuando la evaluación de un elemento falla, la ejecución de la cadena entera es abortada y la cadena entera es evaluada como nula.

<?php
// Before
$firstCategoryName = null;
if (null !== $course) {
    if (null !== $course->categories()->first()) {
        $firstCategoryName = $course->categories()->first()->name();
    }
}

// After
$firstCategoryName = $course?->categories->first()?name();

Named arguments

Ahora podemos pasar parámetros con nombres, lo cuál nos permite pasarlos sin un orden específico.

<?php
final class Person 
{
    public function __construct(
        private string $id,
        private string $name,
        private bool $isActive
    ) {}
}

$course = new Person
(
    name: "Ismael López",
    id: "f938945b203",
    isActive: false
)

Class names

Devuelve el namespace del objeto usando la sintaxis \::class\, su función principal es ayudarnos con la resolución de nombres de clases de los objetos.

<?php
namespace Runcoding\YouTube\PhpModern;

final class Order
{
    public static function create():self
    {
        retun new self();
    }
}

$order = new Order();

var_dump(Order::class);
var_dump($order::class);
var_dump((new Order())::class);
var_dump(Order::create()::class);

Static return type

El nombre de clase especial estática en PHP se refiere a la clase a la que realmente se llamó un método, incluso si el método es heredado. Esto se conoce como \*"enlace estático tardío" (LSB)\*. Está nueva característica permite hacer static también utilizable como un tipo de retorno (junto a los tipos self y parent ya utilizables).

class Foo
{
    public function test(): static
    {
        return new static();
    }
}

Union type

En vez de anotaciones en PHPDoc para combinar tipos, puedes usar una declaración de tipo unión nativa que será validada en el momento de ejecución.

public function foo(Foo|Bar $input): int|float;


public function foo(?Foo $input): int|null;

Throw expressions

Dado que en PHP throw es una declaración, hace que sea imposible lanzar excepciones en lugares donde solo se permiten expresiones, como funciones de flecha, el operador de fusión y el operador ternario / elvis. Está nueva característica permite convertir la declaración throw en una expresión para que estos casos sean posibles.

$triggerError = fn () => throw new MyError();


$foo = $bar['offset'] ?? throw new OffsetDoesNotExist('offset');

Empty catch

Permite la captura de excepciones sin capturarlas en variables, es decir no necesitas declarar la variable donde atrapas la excepción si no la utilizas.

$user = null;
try {
    echo $user ?? throw new Exception();
} catch (Exception) {
    echo "Some error just happened";
}

Attributes

En vez de anotaciones en PHPDoc, puedes usar metadatos estructurados con el sintax nativo de PHP.

// Estos nuevos atributos o anotaciones nos dan forma
// de añadir metadatos a nuestras clases sin tener que parsear
// un PHPDoc completo

use App\Attributes\ExampleAttribute;

@@ExampleAttribute
class foo
{
    @@ExampleAttribute
    public const FOO = 'foo';

    @@ExampleAttribute
    public $x;

    @@ExampleAttribute
    public function foo(@@ExampleAttribute $bar)
    {

    }
}

Constructor property promotion

Menos código repetitivo para definir e inicializar una propiedad.

// Before
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;
    }
}

// After
class Point
{
    public function __construct(
        public float $x = 0.0,
        public float $y = 0.0,
        public float $z = 0.0
    ) {

    }
}

Match expression

Las nuevas expresiones match son similares a switch y tienen las siguientes características:

• Match es una expresión; esto quiere decir que pueden ser almacenadas como variables o devueltas.
• Match soporta expresiones de una línea y no necesitan romper declarar un break.
• Match hace comparaciones estrictas.

$errorCode = 504;
$errorMessage = match($errorCode) {
    404 => 'User not found',
    407 => 'User not verified',
    default => 'Internal server error',
};

Mixed type

Con la adición de tipos escalares en PHP 7, nullables en 7.1, objeto en 7.2 y, por último, tipos de unión en 8.0, las personas que escriben código PHP pueden declarar explícitamente información de tipo para la mayoría de los parámetros de función, retornos de función, así como propiedades de clase.

private array|bool|callable|init|float|null|object|resource|string $anything;


private mixed $anything;

Enlaces

🔗 https://github.com/php/php-src/blob/PHP-8.0/UPGRADING

🔗 https://make.wordpress.org/core/2020/10/06/call-for-testing-php-8-0/

🔗 https://github.com/laravel/framework/pull/33388

🔗 https://www.php.net/releases/8.0/es.php