¡Lanzamiento de PHP8!

Hoy es un día muy importante para la comunidad de desarrolladores y principalmente para quienes trabajamos en PHP ya que en este día se realizó el lanzamiento de PHP8. Al ser una nueva versión principal, seguramente introducirá algunos cambios que “rompan” con aplicaciones que corran en versiones anteriores, por lo que es posible que se necesiten hacer cambios en el código de las mismas, si se desea actualizar a esta versión.

¿Qué hay de nuevo en PHP8?

Como ya es tendencia en otros lenguajes de programación, esta nueva versión hace un fuerte énfasis en el tipado de los datos para asegurar una mayor consistencia de los mismos y una mejor legibilidad del código.

Named arguments (RFC)

Una mejora un tanto cuestionada, pero a mi modo de verlo muy positiva en PHP8 es el uso de los named arguments, que nos permiten evitar el uso del orden de los argumentos que se pasan a una función y referenciarlos directamente por su nombre.

//PHP 7
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
//PHP 8
htmlspecialchars($string, double_encode: false);

Attributes (RFC)

En reemplazo de las anotaciones, ahora se ofrece de forma nativa una nueva sintaxis llamada Attributes, ahorrándonos la necesidad de tener que parsear los PHPDocs.

//PHP 7
/**
* @Route("/api/posts/{id}", methods={"GET", "HEAD"})
*/
class User
{}
  
//PHP 8  
#[Route("/api/posts/{id}", methods: ["GET", "HEAD"])]
class User
{}

Constructor property promotion (RFC)

PHP8 trae una nueva forma de definir e inicializar las propiedades de una clase, con un código mucho más limpio y ordenado.

//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,
  ) {}
}

Union types

En vez de utilizar las anotaciones de PHPDoc para la combinación de tipos, ahora tenemos una solución nativa del lenguaje. La unión de tipos se hace a través del caracter pipe “|” y se puede anteponer el signo de interrogación para indicar que el valor puede ser null.

//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

Match expression (RFC)

Ya hemos hablado anteriormente de match expression en nuestro blog, una alternativa a la sentencia switch con algunas ventajas:

Match es una expresión, por lo que su resultado puede ser guardado en una variable o devolverse desde un método
Cada comparación soporta una expresión de una sola línea y no necesita del uso de la sentencia break;
Match realiza comparaciones de tipo estrictas

//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

Nullsafe operator (RFC)

El operador nullsafe nos permite ahorrarnos muchos dolores de cabeza cuando intentamos acceder a propiedades o métodos cuyo valor podría ser null sin la necesidad de realizar comparaciones molestas ni depender de los helpers de algunos frameworks como optional().

//PHP7
$country =  null;
if ($session !== null) {
  $user = $session->user;
  if ($user !== null) {
    $address = $user->getAddress();
 
    if ($address !== null) {
      $country = $address->country;
    }
  }
}
//PHP8
$country = $session?->user?->getAddress()?->country;

Consistent type errors for internal functions (RFC)

Ahora, la mayoría de las funciones internas lanzan una excepción si los tipos de datos o los datos mismos no son los correctos.

//PHP7
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

Just-In-Time compilation

Y la frutilla del postre es sin dudas el agregado de JIT (Just In Time) Compilation. Se incluyen dos motores diferentes para la compilación en tiempo real.

Tracing JIT el más rápido de los dos, que muestra una velocidad de carga de hasta 3 veces más rápido para apps tipo “synthetic benchmarks” y entre 1.5 y 2 veces para algunas aplicaciones específicas.

algunas pequeñas Conclusiones

Para el lanzamiento de PHP8 podemos decir que el equipo se ha puesto al hombro el desarrollo de una nueva e indiscutiblemente mejor versión del lenguaje.

Como se mencionó anteriormente, y como es tendencia, hay un marcado énfasis en fortalecer el tipado de datos e inducir al desarrollador a buenas prácticas para evitar errores.

Por otro lado, se presentan como siempre, grandes mejoras de performance y seguridad y nuevas sintaxis que permiten tener un código más limpio y legible.

Enhorabuena por esta nueva versión, ya estamos ansiosos por empezar a implementarla en nuestros desarrollos.

Todas estas nuevas características (y varias más), pueden encontrarlas en la not a oficial en el sitio de PHP.

#LoHacemosAdue