Released!

PHP 8.0 es una actualización importante del lenguaje PHP que contiene nuevos recursos y optimizaciones incluyendo argumentos nombrados, tipos de uniones, atributos, promoción de propiedades constructivas, expresiones match, operador nullsafe, JIT (traducción dinámica) y también mejoras en el sistema de tipos, manejo de errores y consistencia en general.

Actualizate a PHP 8!

Argumentos nombrados

Solamente especifica los parámetros requeridos, omite los opcionales.
Los argumentos son independientes del orden y se documentan automáticamente.

htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);

htmlspecialchars($string, double_encode: false);

Atributos

En vez de anotaciones en PHPDoc, puedes usar metadatos estructurados con la sintaxis nativa de PHP.

class PostsController
{
    /**
     * @Route("/api/posts/{id}", methods={"GET"})
     */
    public function get($id) { /* ... */ }
}

class PostsController
{
    #[Route("/api/posts/{id}", methods: ["GET"])]
    public function get($id) { /* ... */ }
}

Promoción de propiedades constructivas

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

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

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

Tipos de unión

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.

class Number {
    /** @var int|float */
    private $number;

    /**
     * @param float|int $number
     */
    public function __construct($number) {
        $this->number = $number;
    }
}

new Number('NaN'); // Ok

class Number {
    public function __construct(
        private int|float $number
    ) {}
}

new Number('NaN'); // TypeError

Expresiones match

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.

switch (8.0) {
    case '8.0':
        $result = "Oh no!";
        break;
    case 8.0:
        $result = "This is what I expected";
        break;
}
echo $result;
//> Oh no!

echo match (8.0) {
    '8.0' => "Oh no!",
    8.0 => "This is what I expected",
};
//> This is what I expected

Operador Nullsafe

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 entire cadena es abortada y la cadena entera es evaluada como null.

$country =  null;

if ($session !== null) {
    $user = $session->user;

    if ($user !== null) {
        $address = $user->getAddress();

        if ($address !== null) {
            $country = $address->country;
        }
    }
}

$country = $session?->user?->getAddress()?->country;

Comparaciones inteligentes entre “strings” y números

Cuando comparas con un “string” numérico, PHP8 usa comparación numérica o de otro caso convierte el número a un "string" y asi los compara.

0 == 'foobar' // true

0 == 'foobar' // false

Errores consistentes para funciones internas.

La mayoría de las funciones internas ahora proveen un Error de excepción si el parámetro no es validado.

strlen([]); // Warning: strlen() expects parameter 1 to be string, array given

array_chunk([], -1); // Warning: array_chunk(): Size parameter expected to be greater than 0

strlen([]); // TypeError: strlen(): Argument #1 ($str) must be of type string, array given

array_chunk([], -1); // ValueError: array_chunk(): Argument #2 ($length) must be greater than 0

JIT (traducciones dinámicas)

PHP8 introduce 2 motores de compilación JIT. Transit JIT, es el más prometedor de los dos y performa 3 veces mejor en benchmarks sintéticos y 1.5-2 mejor en algunas aplicaciones específicas a largo plazo. Performancia de aplicaciones típicas es a la par de las de PHP7.4

JIT contribuciones al funcionamiento relativo de PHP8

Mejorias en los tipos de sistemas y manejo de errores

Verificaciones estrictas de operadores aritméticos/bitwise. RFC
Validación de métodos con características abstractas RFC
Firmas correctas de métodos mágicos RFC
Reclacificamiento de errores fatales RFC
Errores fatales incompatibles con el método de firma RFC
El operador @ no omitirá errores fatales.
Herencia con métodos privados RFC
Tipo mixed RFC
Tipo retorno static RFC
Tipos para funciones internas Email thread
Objetos opacos en ves de recursos para Curl, Gd, Sockets, OpenSSL, XMLWriter, y XML extensiones

Otros ajustes y mejoras del sintax

Permitir una coma al final de una lista de parámetros RFC y lista de use en closures RFC
Catches que no capturan RFC
Ajustes al syntax variable RFC
Tratamiento de nombres de namespace como tokens únicos RFC
throw es ahora una expresión RFC
Permitir ::class on objects RFC

Nuevas clases, interfaces y funciones

Weak Map clase
Stringable interface
str_contains(), str_starts_with(), str_ends_with()
fdiv()
get_debug_type()
get_resource_id()
token_get_all() Implementación de objeto
New DOM Traversal and Manipulation APIs

Mejor performancia, mejor syntax, aumentada seguridad de tipos.

Para bajar el código fuente de PHP8 visita la página downloads. Código binario para windows lo puedes encontrar en la página PHP for Windows. La lista de cambios está disponible en la página ChangeLog.

La guía de migración está disponible en el manual de PHP. Por favor consultala para una lista detallada de alteraciones cambios y compatibilidad.