El año 2020 fue el lanzamiento de la versión 8.0 del lenguaje de programación PHP. Y el año 2021 nos trae la versión 8.1 con varias novedades pensadas para facilitar las tareas de programación respecto a sus versiones predecesoras.
En este artículo, repasamos las novedades más destacadas de PHP 8.0 y 8.1 que pueden mejorar nuestra programación en este lenguaje.
Compilador JIT
PHP 8 introduce la llamada compilación “Just in time” como una opción de OPcache. Esta característica realiza una compilación de nuestro código PHP en tiempo real, con el objetivo de buscar un mayor rendimiento en problemas complejos.
Este tipo de compilación abre la puerta a que PHP pueda ser usado en aplicaciones de machine learning, análisis de datos o renderizado.
Mejoras en comparación de valores
Si has realizado comparaciones entre valores enteros y cadenas de texto en PHP7, seguramente habrás experimentado resultado indeseados. Esto cambia en PHP 8, ya que introduce una mejora en la comparación de estos valores:
Comparison | PHP7 | PHP8
------------------------------
0 == "0" | true | true
0 == "0.0" | true | true
0 == "foo" | true | false
0 == "" | true | false
42 == " 42" | true | true
42 == "42foo" | true | falsePropiedades de "solo lectura"
PHP 8.1 introduce las propiedades “readonly” (solo lectura). Estas propiedades tienen la peculiaridad de que solo pueden ser inicializadas una única vez. Una vez establecido su valor, éste no podrá ser modificado.
class User {
public readonly int $uid;
public function __construct(int $uid) {
$this->uid = $uid;
}
}Operador null-safe
PHP 8 incluye un nuevo operador null-safe que permite ahorrar líneas de código en comprobaciones de valor nulo.
En un código escrito en PHP 7, tendríamos que realizar un gran número de verificaciones de valor nulo para asegurarnos de acceder a determinados datos de forma segura:
if ($session !== null) {
$user = $session->user;
if ($user !== null) {
$address = $user->getAddress();
if ($address !== null) {
$country = $address->country;
}
}
}En PHP 8, el nuevo operador null-safe nos permitirá realizar estas comprobaciones de forma implicita:
$country = $session?->user?->getAddress()?->country;Constructores: Promoción de propiedades
Una de las características más interesantes introducidas por PHP 8 y que permitirá ahorrar lineas de código, es la promoción de propiedades en los métodos constructores.
Mientras que en PHP 7 era necesario asignar los valores de los argumentos recibidos en un método constructor a las propiedades de la clase:
class User {
private string $name;
public function __construct(string $name) {
$this->name = $name;
}
}En PHP 8 se realizará esta lógica de forma automática sin necesidad de declarar las variables de la clase, ni realizar las asignaciones en el constructor:
class User {
public function __construct(private string $name) {}
}Constantes finales
En PHP 8, las constantes de una clase pueden ser declaradas como “finales”. Esto implica que a la hora de heredar una clase, sus constantes finales no podrán ser sobreescritas:
class User {
final public const MIVALOR = '1';
}Nombrado de argumentos
Otra característica introducida en PHP 8 es el nombrado de argumentos a la hora de llamar a una función.
Mientras que en PHP 7, los argumentos de una función debían pasarse en el orden indicado en la definición de la función. En PHP 8, puede llamarse a las funciones definiendo sus parámetros a modo de diccionario:
function foo($a = 10, $b = 20, $c = 30) {
return $a * $b - $c;
}
foo(a:30, c:50);Union Types
PHP 8 permite definir múltiples tipos para las variables, argumentos y tipos devueltos por funciones. Esto soluciona el problema introducido en PHP 7 que únicamente permitía indicar un tipo de valor para cada dato.
class User {
private int|float $a;
public function test(float|int $b): int|float {
return $this->a * $b;
}
}Tipo de retorno: "never"
PHP 8.1 introduce el tipo de retorno “never” para aquellas funciones sin sentencia “return”. Mientras que el tipo de retorno “void” permite el uso de sentencias “return” vacías, el tipo “never” no permite su uso.
public function testFn1(): never {
// ...
}
public function testFn2(): void {
// ...
return;
}Tipo de retorno: "static"
Otro tipo de valor de retorno introducido en PHP 8 es el tipo “static”. Este tipo debe utilizarse en funciones que devuelven una instancia de la clase actual:
public function testFn1(): static {
$clone = clone $this;
return $clone;
}
public function testFn2(): static {
return $this;
}Expresión "match"
PHP 8 introduce la nueva expresión “match”, muy similar a un switch .. case, pero algo más simple. Por ejemplo:
switch ($i) {
case 'a':
$a = 1;
break;
case 'b':
case 'c':
$a = 2;
break;
default:
$a = 3;
}Puede ser escrito del siguiente modo, utilizando una expresión “match”:
$a = match($i) {
'a' => 1,
'b', 'c' => 2,
'default' => 3
};First Class Callable
PHP 8 facilita la obtención de objetos de tipo “callable” a partir de funciones:
$callable = strtoupper(...);$callable = $item->doSomething(...);$callable = $item::doSomething(...);Enums
Otra característica introducida en PHP 8.1 es el tipo de dato “enum”. Este tipo de dato permite definir un conjunto con una serie de datos fijos:
enum Suit {
case Clubs;
case Diamonds;
case Hearts;
case Spades;
}enum SuitSymbol: string {
case Clubs = '♣';
case Diamonds = '♦';
case Hearts = '♥';
case Spades = '♠';
}Estas enumeraciones pueden utilizarse tanto para definir un tipo de dato de entrada o salida para una función, como para acceder a los diferentes valores que contienen:
function getSuit(Suit $suit): void {
// ...
}
getSuit(Suit::Clubs);function getSuitSymbol(SuitSymbol $suit): string {
return $suit->value;
}
getSuitSymbol(SuitSymbol::Clubs);Fibers
PHP 8.1 introduce el nuevo concepto de “Fiber”, que representa algo similar a un hilo de ejecución. Estos “Fiber” pueden encapsular determinada lógica y cuentan con funciones para lanzar, pausar y reanudar su ejecución.
$fiber = new Fiber(function() : void {
// ...
Fiber::suspend();
// ...
});
$fiber->start();
$fiber->resume();
