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.

Argumentos nombrados RFC

PHP 7
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
PHP 8
htmlspecialchars($string, double_encode: false);
  • Solamente especifica los parámetros requeridos, omite los opcionales.
  • Los argumentos son independientes del orden y se documentan automáticamente.

Atributos RFC Doc

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

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

Promoción de propiedades constructivas RFC Doc

PHP 7
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;
  }
}
PHP 8
class Point {
  public function
__construct(
    public
float $x = 0.0,
    public
float $y = 0.0,
    public
float $z = 0.0,
  ) {}
}

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

Tipos de unión RFC Doc

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

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

new
Number('NaN'); // Ok
PHP 8
class Number {
  public function
__construct(
    private
int|float $number
 
) {}
}

new
Number('NaN'); // TypeError

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.

Expresiones match RFC Doc

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

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.

Operador Nullsafe RFC

PHP 7
$country null;

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

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

    if (
$address !== null) {
     
$country = $address->country;
    }
  }
}
PHP 8
$country = $session?->user?->getAddress()?->country;

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 nula.

Comparaciones inteligentes entre “strings” y números RFC

PHP 7
0 == 'foobar' // true
PHP 8
0 == 'foobar' // false

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.

Errores consistentes para funciones internas. RFC

PHP 7
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
PHP 8
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

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

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

Just-In-Time compilation

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
  • Tipos mixtos RFC
  • Tipo retorno statico 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 únicosRFC
  • Throw es ahora una expresión RFC
  • Permitir ::class on objects RFC

Nuevas clases, interfaces y funciones

To Top