Hace poco se lanzó PHP 8, la nueva versión del popular lenguaje de programación del lado del servidor que todos conocemos.
PHP es uno de los lenguajes más usados en la web, por muchos motivos, uno de ellos su rico ecosistema de tecnologías a su alrededor. Frameworks, librerías, CMS´s, una comunidad muy amplia, demanda laboral elevada han convertido a PHP en uno de los mejores lenguajes de backend.
PHP 7 trajo muchas mejoras de rendimiento para el lenguaje y actualmente es la versión estable, que seguramente estés usando en tu servidor o en tu hosting.
Pero la versión 8 de PHP, no solamente trae mejoras de rendimiento, además también trae nuevas funcionalidades que van a ser muy útiles a los que programamos con PHP.
En los siguientes puntos vamos a ver lo nuevo de PHP 8.
Compilador JIT
Una de las principales novedades de PHP 8 es el compilador JIT (Just in Time), que permite compilar partes del código sobre la marcha, en tiempo de ejecución.
Esta funcionalidad, se lleva preparando varios años y supone un cambio increíble en el ecosistema PHP, porque mejora el rendimiento de aplicaciones escritas en PHP 8 y en algunos casos lo multiplica hasta por 4.
Esto no solo mejorará el funcionamiento de aplicaciones desarrolladas con frameworks como Laravel o Symfony y con CMS como WordPress o Drupal, si no que también abre las puertas al uso de PHP como lenguaje de programación para otros usos aparte de la web.
El compilador JIT podrá habilitarse en el archivo php.ini, permitirá almacenar el código nativo de los ficheros PHP en un apartado adicional de la memoria compartida OPcache de esta manera:
# Enabling JIT in php.ini opcache.enable=1 opcache.jit_buffer_size=100M opcache.jit=tracing
Operador nullsafe
Otra novedad es la implementación del operador nullsafe, que soluciona un «problema» muy concreto.
Cuando queremos comprobar en PHP que una propiedad de un objeto o un método no devuelve null, teníamos que a estar haciendo ifs para comprobar si esa propiedad o método nos da null o no. Ahora con el operador nullsafe, si la primera propiedad, o el primer método, me devuelve null se anula la ejecución de toda la cadena.
Ejemplo en PHP clásico:
$universidad = null;
if ($session !== null) {
$usuario = $session->usuario;
if ($usuario !== null) {
$estudios = $usuario->getEstudios();
if ($estudios !== null) {
$universidad = $estudios->universidad;
}
}
}
Ejemplo en PHP 8:
$universidad = $session?->usuario?->getEstudios()?->universidad;
Esto ahorra tiempo y favorece a un código más limpio.
Parámetros con nombre
En otros lenguajes de programación desde hace años existían los parámetros o argumentos con nombre, lo cual nos permitía no tener que seguir un orden concreto a la hora de pasar parámetros a una función, simplemente le pasábamos el nombre del parámetro y su valor y con eso era suficiente. Pues justamente esto lo han implementado en PHP 8 y ya no tiene que coincidir el orden de los parámetros.
Ejemplo de función en PHP:
function mostrarCurso($nombre, $profesor, $horas){
return "Bienvenido al $nombre, impartido por $profesor, que tiene $horas horas de contenido :)";
}
Ejemplo invocar función en PHP 8:
echo mostrarCurso(
horas: 56,
nombre: 'Master en PHP',
profesor: 'Víctor Robles'
);
Así podemos poner el orden que queramos en los argumentos. También se puede hacer de forma clásica:
echo mostrarCurso('Master en PHP', 'Víctor Robles', 56);
Es una buena novedad.
Match Expression
PHP8 trae una nueva expresión o «estructura de control» parecida a switch, pero más sencilla de escribir y con la capacidad de devolver valores.
Esto funciona igual que un switch:
$genero_id = $_POST["genero_id"];
$genero = match($genero_id ) {
1 => 'Hombre',
2 => 'Mujer',
default => 'Otro'
};
echo $genero;
Me gusta, es útil.
Union Types
Normalmente en PHP, podíamos especificar tipos de unión mediante anotaciones PHPdoc, ahora PHP 8 añade soporte para los tipos de unión en las firmas de las funciones, ahorrándonos así, mucho código.
Ejemplo en PHP clásico:
class Empleado {
/**
* @var int
*/
private $edad;
/**
* @param int|float $sueldo
* @return int|float
*/
public function getSueldoAnual(int $sueldo): int {
$anual = $sueldo * 12;
return $anual;
}
}
Ejemplo en PHP 8:
class Empleado {
private int $edad;
public function getSueldoAnual(int|float $sueldo): int|float {
$anual = $sueldo * 12;
return $anual;
}
}
De esta manera podemos determinar que tipo de dato tiene cada propiedad, parámetro o return que hagamos.
Expresión throw
Ahora el throw en lugar de una declaración, se considera una expresión y se puede usar en más casos.
throw new Exception('Algo va mal!');
Puede ser útil en algunos casos.
Propagación de propiedades
Cuando definimos una propiedad en PHP, teníamos que repetirla hasta 3 veces para usarla como pametros de un objeto. Ahora PHP 8, incluye csta nueva característica, que ya estaba en tecnologias como TypeScript, nos permite reducir mucho la cantidad de código que escribimos.
Ejemplo en PHP clásico:
class Persona
{
public $nombre;
public $email;
public $edad;
public function __construct(
$nombre,
$email,
$edad
) {
$this->nombre = $nombre;
$this->email = $email;
$this->edad = $edad;
}
}
Ejemplo en PHP 8:
class Persona
{
public function __construct(
$nombre,
$email,
$edad
) {}
}
En PHP8 hacemos los 3 pasos en uno solo.
::class en objetos
Para buscar el nombre completo de una clase o su namespace completo podemos usar ::class, esto hasta ahora lo podiamos usar solo en clases y no en instancias de objetos.
Ejemplo en una clase de formularios en Symfony:
namespace App\Controller;
use App\Entity\Task;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Form\Extension\Core\Type\DateType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
class TaskController extends AbstractController
{
public function new(Request $request): Response
{
$task = new Task();
$task->setTask('Write a blog post');
$task->setDueDate(new \DateTime('tomorrow'));
$form = $this->createFormBuilder($task)
->add('task', TextType::class)
->add('dueDate', DateType::class)
->add('save', SubmitType::class, ['label' => 'Create Task'])
->getForm();
// ...
}
}
En el método add necesitamos pasar como segundo parámetro el espacio de nombre completo y usamos ::class sobre una clase que ya estamos usando en la clase actual, para sacar el namespace completo.
Ahora en PHP8:
$miObjeto = new stdClass; var_dump($miObjeto::class);
En PHP 8, $miObjeto::class nos da el mismo resultado que get_class($miObjeto). Si $miObjeto no es un objeto, lanzará una excepción TypeError.
Y estas serian las novedades más importantes de la nueva versión de PHP, hay algunas cosillas mas que han agregado, pero no son tan relevantes y tampoco hay cambios que rompan nada de las versiones anteriores, es decir se programa exactamente igual, lo unico que han agregado mejoras a nivel de rendimiento y nuevas funcionalidades.
Si quieres aprender más de PHP te recomiendo este curso: Curso de PHP, el más completo en Español.
Y si quieres alojar tus sitios web hechos con PHP te recomiendo este alojamiento web: Hosting para PHP bueno, rapido y barato.
