PHP 8 se lanzará durante Noviembre de 2020. Se trata de una nueva versión principal, lo que significa que introducirá algunos cambios importantes, así como muchas características nuevas y mejoras de rendimiento.

PHP8 ayudará a los programadores y desarrolladores a escribir código más limpio, con tiempos de ejecución más rápidos y de mayor calidad.

A partir de Diciembre de 2020 ya se podrá seleccionar la versión de PHP8 en nuestros planes de alojamiento

Además de los cambios importantes, PHP 8 también trae un buen conjunto de nuevas características como el compilador JIT, tipos de unión, atributos y mucho más…

¿Cuáles son las nuevas funciones que vienen con PHP 8?

A continuación os explicaremos algunas de las funciones principales y mejoras que se incluyen en PHP 8.

JIT

Entre las principales novedades de PHP 8 se encuentra el compilador JIT (Just In Time), que debería mejorar el rendimiento de forma significativa. El compilador JIT funciona compilando partes del código durante el tiempo de ejecución y, al hacerlo, actúa como una versión en caché del código. Esto debería notarse como una gran mejora en rendimiento.

Union Types

La siguiente característica debería ser útil ya que PHP es un lenguaje escrito dinámicamente. Los tipos de unión te permiten especificar 2 o más tipos aceptables para un argumento o tipo de retorno. PHP ya admite dos tipos de unión especiales (Type o null usando la sintaxis especial ?Type y array o Traversable usando el tipo iterable).
Ahora, en lugar de manejar tipos con anotaciones phpdoc, se podría usar lo siguiente:

class Number {
    private int|float $number;

    public function setNumber(int|float $number): void {
        $this->number = $number;
    }

    public function getNumber(): int|float {
        return $this->number;
    }
}

Como puede que estes familiarizado con usar ? para representar nullable, también podrías usar null:

public function handle(Product|null $product): int
// equals
public function handle(?Product $product): int

Named Arguments

Los Named Arguments permiten pasar argumentos a una función en función del nombre del parámetro, en lugar de la posición del parámetro. Aquí un ejemplo rápido:

// Positional arguments
json_encode($data, 0, 512);

// Named arguments
json_encode(value: $data, options: 0, depth: 512);

Atributos

Los atributos son, sin duda, una de las mayores nuevas adiciones a PHP. Los atributos ayudan a agregar metadatos a funciones, parámetros, clases, métodos, constantes, propiedades, etc… lo que antes se simulaba a través de docblocks y luego se analizaba en cualquier otro lugar. Los atributos ahora son first-clase en PHP y se puede acceder a ellos mediante programación.

@@Route(Http::POST, '/store/123/item')
class ItemCreateHandler
{
    public function __invoke() {
        // ...
    }
}

Expresión match

Es una alternativa al conocido switch con muchas ventajas y mejoras.

//Before
switch ($x) {
    case 1:
        $y = 3;
        break;
    case 2:
        $y = 4
        break;
    case 3: case 4:
        $y = 5;
        break;
    ...
    default:
        throw new \RuntimeException('Not happening, bud');
} 

//New
$y = match ($x) {
    1 => 3,
    2 => 4,
    3, 4 => 5,
    ...
    default => throw new \RuntimeException('Not happening, bud'),
}

Es importante tener en cuenta que la nueva expresión match ahora devuelve un valor, por lo que no es necesario repetir la asignación en todos los cases.

Promoción de propiedades del constructor

A partir de ahora, los nuevos constructores pasaran de repetirse una y otra vez a verse así:

//Before
class Response {
    private int $code;
    private string $body;
    private array $headers;

    public function __construct(int $code, string $body, array $headers) {
        $this->code = $code;
        $this->body = $body;
        $this->headers = $headers;
    }
}

//New
class Response {
    public function __construct(
        private int $code,
        private string $body,
        private array $headers,
    ) {}
}

Nuevo tipo Static

Además de self, ahora se añade static.

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

Nuevo tipo Mixed

Puede ocurrir que en ocasiones este tipo de inclusiones son algo así como un comodín que acaba volviéndose en nuestra contra molestando más de lo que nos ayuda, gracias a la función mixed, podremos definir entradas y salidas.

Mixed nos ahorrará concatenar muchos tipos de parámetros: array, bool, callable, int, float, null, object, resource y string.

¿Eres programador y quieres información detallada sobre todos los cambios?

En este artículo hemos tratado algunos de los cambios más interesantes, si quieres verlos todos, puedes revisarlos en slitcher.io

¿Buscas un alojamiento para tu web?

Consulta nuestros planes

Author

Inicié mi carrera en DonDominio el año 2011 como agente de soporte, creciendo paso a paso hasta llegar a director de marketing en el 2018, cargo que sigo ocupando en la actualidad.

Write A Comment