PHP 8 ventajas y ejemplos de su potencial frente a PHP 7

PHP 8 ha introducido varias características innovadoras que han mejorado significativamente el rendimiento y la facilidad de uso del lenguaje. Una de las más destacadas es la introducción del compilador Just-In-Time (JIT).

Compilador Just-In-Time (JIT)

El compilador JIT es una característica interna y no cambia la sintaxis del código PHP, permite que PHP compile el código en tiempo de ejecución, lo que puede mejorar considerablemente el rendimiento de las aplicaciones PHP. En lugar de interpretar el código PHP en cada solicitud, el código compilado se almacena en memoria compartida y puede ser ejecutado directamente. Esto reduce el tiempo de procesamiento y mejora la eficiencia general del servidor.

En PHP 8, el compilador JIT (Just-In-Time) no está habilitado por defecto. Para activarlo, necesitas configurar el archivo php.ini, estos son los pasos básicos:

1. Habilita la extensión OPcache. Esto suele estar activado por defecto, pero es bueno verificarlo. En el archivo php.ini, busca y asegúrate de que opcache.enable esté configurado.
2. Configura el tamaño del búfer JIT. Agrega o modifica la línea opcache.jit_buffer_size en el archivo php.ini. Un valor común es 128M, pero puedes ajustarlo según tus necesidades.
3. Configura otras opciones JIT (opcional). Puedes ajustar otras configuraciones como opcache.jit para controlar el comportamiento del JIT.

Ejemplo de cómo puede verse en el archivo php.ini:

iniopcache.enable=1
opcache.enable_cli=1
opcache.jit_buffer_size=128M
opcache.jit=tracing

Otras Nuevas Funcionalidades

Además, PHP 8 también ha introducido otras características interesantes, como las que veremos a continuación:

1 Argumentos Nombrados (Named Arguments)

Permiten especificar argumentos por nombre, lo que hace que el código sea más legible y fácil de mantener.

PHP 7function createUser($name, $email, $role = 'user') {
  // Código para crear un usuario
}
createUser('John Doe', 'john@example.com', 'admin');

PHP 8function createUser($name, $email, $role = 'user') {
  // Código para crear un usuario
}
// Usando argumentos nombrados
createUser($name: 'John Doe', email: 'john@example.com', role: 'admin');

2 Tipos de Unión (Union Types)

Permiten que una variable tenga múltiples tipos, lo que aumenta la flexibilidad y la robustez del código.

PHP 7function parseNumber($number) {
  if (is_int($number)) {
    // Procesar entero
  } elseif (is_float($number)) {
    // Procesar flotante
  }
}
parseNumber(42);
parseNumber(42.0);

PHP 8function parseNumber(int|float $number) {
    // Procesar número
}
parseNumber(42);
parseNumber(42.0);

3 Operador Nullsafe

Facilita la verificación de valores nulos, evitando la necesidad de múltiples comprobaciones de nulidad.

PHP 7$country = null;
if ($user !== null) {
  if ($user->getAddress() !== null) {
    $country = $user->getAddress()->getCountry();
  }
}

PHP 8$country = $user?->getAddress()?->getCountry();

4 Promoción de Propiedades del Constructor (Promotion Construct Properties)

Simplifica la definición y asignación de propiedades en el constructor de una clase. Beneficioso para ahorrar código.

PHP 7class User {
    public $name;
    public $email;

    public function __construct($name, $email) {
    $this->name = $name;
    $this->email = $email;
 }
}

PHP 8class User {
    public string $name,
    public string $email
) {}
}

5 Expresión de Coincidencia (Match expression)

Similar a switch pero no requiere del break, es más potente y flexible.

PHP 7$status = 200;
switch ($status) {
  case 200:
      $message = 'OK';
      break;
  case 404:
      $message = 'Not Found';
      break;
  default:
      $message = 'Unknown status';
}

PHP 8$status = 200;
  $message = match ($status) {
      200 => 'OK',
      404 => 'Not Found',
      default => 'Unknown status',
};

6 Atributos

Los atributos son una forma de añadir información adicional, llamada metadatos, directamente en el código, de manera estructurada. Esta información puede ser utilizada por otras partes del programa, como frameworks o herramientas de análisis, para modificar el comportamiento del código en tiempo de ejecución.

La sintaxis para los atributos utiliza #[...] y se coloca antes de la declaración del elemento al que se aplican (clase, método, propiedad, etc.).

Con PHP 8 en vez de anotaciones en PHPDoc, podemos usar metadatos estructurados con el sintaxis nativa de PHP.

Antes de PHP 8, se utilizaban comentarios de PHPDoc para agregar metadatos, por ejemplo:

PHP 7/**
* @Route("/home")
*/
function home() {
  // Código de la función
}

Con PHP 8, puedes usar atributos para lograr lo mismo de una manera más estructurada:

PHP 8#[Route("/home")]
function home() {
  // Código de la función
}

7 Comparaciones inteligentes entre strings y números

Cuando comparo con un 'string' numérico, PHP 8 utiliza una comparación numérica; en caso contrario, convierte el número en un 'string' para realizar la comparación.

PHP 7var_dump('123' == 123); // true
var_dump('123abc' == 123); // true (inconsistente)

PHP 8var_dump('123' == 123); // true
var_dump('123abc' == 123); // false (consistente)

8 Errores de tipo consistentes para funciones interna

En PHP 8, se introdujo una mejora importante en la gestión de errores de tipo para las funciones internas. Anteriormente, en PHP 7, muchas funciones internas devolvían false o null cuando fallaban, incluso si el fallo se debía a parámetros inválidos. Esto a menudo resultaba en errores difíciles de depurar, ya que el fallo podía pasar desapercibido hasta mucho después en el flujo del código.

La mayoría de las funciones internas ahora lanzan una excepción de error si falla la validación de los parámetros.

En PHP 7, una función como array_key_exists simplemente devuelve false si la clave no existe en el array, lo cual es esperado. Sin embargo, otras funciones internas podrían devolver false o null silenciosamente si se les pasaban parámetros incorrectos o inválidos.

PHP 7$array = [1, 2, 3]; 
var_dump(array_key_exists(4, $array)); // false

Aquí, la función devuelve false porque la key 4 no existe en el array. Esto es normal y esperado, pero otras funciones podrían no ser tan claras sobre los errores de tipo.

En PHP 8, se busca que los errores de tipo sean más consistentes y explícitos. En lugar de devolver false o null, las funciones internas lanzarán una excepción de error cuando se encuentren con parámetros inválidos. Esto ayuda a detectar y manejar los errores de manera más efectiva y temprana en el código.

PHP 8$array = [1, 2, 3]; 
var_dump(array_key_exists(4, $array)); // false, pero errores más consistentes en otros casos

Es decir, que si intentamos pasar un parámetro inválido a una función interna en PHP 8, ahora obtendremos una excepción como en el siguiente ejemplo:

PHP 8// Intentando acceder a una función con un tipo incorrecto
try { 
    echo strlen(array());
} catch (TypeError $e) { 
    echo "Error: " . $e->getMessage(); 
}
//Error: strlen(): Argument #1 ($string) must be of type string, array given

Esto lanzará una excepción TypeError, indicando claramente que ha habido un problema con el tipo de parámetro proporcionado.

Conclusión

Habilitar JIT en PHP 8 puede mejorar el rendimiento sin necesidad de alterar el código fuente.

Los ejemplos que hemos visto demuestran cómo las nuevas características de PHP 8 pueden mejorar significativamente la claridad y el rendimiento del código en comparación con PHP 7.

Estas mejoras convierten a PHP 8 en una herramienta aún más poderosa y eficiente, mejorando la legibilidad y mantenibilidad del código, aspectos esenciales en el desarrollo web. Al aumentar la consistencia y claridad de los errores de tipo en las funciones internas, se consigue un desarrollo y una depuración más eficientes y menos propensos a errores silenciosos.

✨🚀✨

Solicita presupuesto sin compromiso