actualización mayor de php 8

PHP 8 - Nuevas funciones y posibles problemas con WordPress

¡Ya está aquí PHP 8! La gran actualización se publicó el 26 de noviembre de 2020 y nos trae algunos cambios fundamentales, así como muchas nuevas funciones. Nuestro desarrollador Marten nos explica en qué casos PHP 8 realmente mejora el rendimiento y si deberías actualizar ya a la nueva versión como usuario de WordPress.

Introducción a PHP 8 

PHP 8 se presentó por primera vez a sus probadores alfa el 18 de junio de 2020 y ha estado en una congelación de características desde julio. Por lo tanto, no se permitió añadir nuevas adiciones hasta la publicación del 26 de noviembre. Una característica especial de esta versión es que nos saltamos PHP 7.5 y pasamos directamente a PHP 8. Y este salto está relacionado con una multitud de características. 

Una de las preguntas más comunes sobre PHP 8 que probablemente se hacen los usuarios de WordPress es: ¿mejorará PHP 8 el rendimiento de mi sitio web?

La respuesta a esta pregunta es (como suele ocurrir): "Depende...".

Cuando se actualizó PHP de la versión 5 a la 7, se produjo un gran aumento del rendimiento. Sin embargo, con PHP 8 no verás una mejora general del rendimiento, a menos que la aplicación tu calcule muchas funciones matemáticas (consulta nuestra sección sobre el compilador JIT). Esto se debe principalmente a que la optimización del código de PHP ya está muy bien establecida.

¿Pero quién dice que el rendimiento se limita al tiempo de compilación? Por mi parte, como desarrollador, mediría el rendimiento de varias maneras, incluyendo las características de las que dispongo para escribir un código bien estructurado. Y PHP 8 está lleno de novedades. Así que, ¡comencemos!

Actualizaciones de funciones en PHP 8 

PHP 8 tiene ocho nuevas características principales que me gustaría presentarte brevemente: 

  1. El compilador JIT 
  2. Atributos
  3. Argumentos con nombre
  4. Expresiones de coincidencia 
  5. Expresiones de lanzamiento
  6. Tipo de retorno estático 
  7. Tipo de unión 
  8. Tipos mixtos 

El compilador JIT (just-in-time)(rfc)

Cuando se ejecuta el código PHP, normalmente se hace compilándolo en instrucciones virtuales que se ejecutan en una máquina virtual. El JIT cambiará esto al compilar el código en código máquina x86 y luego ejecutar ese código directamente en la CPU. Para las aplicaciones que dependen en gran medida de las funciones matemáticas, esto debería suponer un aumento del rendimiento. Sin embargo, para la aplicación web media, esto no es de esperar (ver gráfico). 

PHP 8 - Nuevas funciones y posibles problemas con WordPress
Fuente

Para ver un ejemplo de la mejora del rendimiento que se puede conseguir con el JIT, lo mejor es ver el siguiente vídeo.

Básicamente, si utilizas PHP para una tarea matemática intensiva, tu funcionará mejor con la nueva versión. Pero si usas PHP como la mayoría de los usuarios de WordPress, no notarás mucho el cambio. A continuación explico más sobre lo que significa PHP 8 para los propietarios de sitios web de WordPress. 

Sigamos con las nuevas características:

Atributos v2(rfc, rfc)

Una de las innovaciones de PHP 8 (que ha dado lugar a amplios debates en la comunidad PHP) son los atributos, conocidos como "anotaciones" en muchos otros lenguajes. En PHP 8, los atributos sustituyen el almacenamiento de metadatos por docblocks. Hasta ahora, tenías que recurrir a esto para declarar los metadatos de las clases, métodos, funciones y argumentos de forma estructurada. 

Como puedes imaginar, utilizar los comentarios del código para aplicar los metadatos no era lo ideal, pero funcionaba. Afortunadamente, ya no tendremos este problema. 

Los atributos se pueden definir con la tecla Syntax #[...] se declare.

Aquí tienes algunos ejemplos de la RFC sobre cómo se pueden aplicar los atributos a diferentes tipos de datos.

#[ExampleAttribute]
class Foo
{
    #[ExampleAttribute]
    public const FOO = 'foo';
 
    #[ExampleAttribute]
    public $x;
 
    #[ExampleAttribute]
    public function foo(#[ExampleAttribute] $bar) { }
}
 
$object = new #[ExampleAttribute] class () { };
 
#[ExampleAttribute]
function f1() { }
 
$f2 = #[ExampleAttribute] function () { };
 
$f3 = #[ExampleAttribute] fn () => 1;

Llegados a este punto, cabe destacar que la RFC de Atributos ha sufrido una serie de cambios desde su concepción original, lo que demuestra el esfuerzo y la reflexión que se ha realizado en esta actualización. 

Argumentos con nombre(rfc)

Los argumentos con nombre te dan más flexibilidad a la hora de llamar a las funciones. Hasta ahora, tenías que llamar a una función y pasar cada argumento en el orden dado por la función. 

// Using positional arguments:
array_fill(0, 100, 50);

Con los argumentos con nombre puedes definir un nombre para cada parámetro. Y ahora se pueden llamar fuera de orden como se describe a continuación: 

// Using named arguments:
array_fill(start_index: 0, num: 100, value: 50);

También se puede acceder a ellos de la siguiente manera

array_fill(value: 50, num: 100, start_index: 0);

También es posible un híbrido de los dos, que permite combinar parámetros con nombre y argumentos posicionales, mejorando la legibilidad del código: 

htmlspecialchars($string, double_encode: false);

Expresiones de coincidencia(rfc)

Match Expressions pretende resolver algunos problemas de larga duración en la funcionalidad de su predecesor, Switch. 

Operador de comparación

Switch utiliza un operador de comparación de tipo (==), que puede dar problemas. En cambio, Match utiliza un operador de comparación estricto (===), independiente de strict_types.

Valor de retorno

Las sentencias de conmutación suelen crear un valor que se necesita más adelante en el flujo del programa. Puede ocurrir que este valor no se establezca en la sentencia switch, lo que puede provocar posteriormente problemas en el script PHP. Además, la sintaxis de la sentencia switch dificulta la lectura de las sentencias switch anidadas.

switch (1) {
    case 0:
        $y = 'Foo';
        break;
    case 1:
        $y = 'Bar';
        break;
    case 2:
        $y = 'Baz';
        break;
}
 
echo $y;
//> Bar

La nueva expresión de coincidencia elimina este problema al asignar el valor de retorno directamente para cada rama de coincidencia(=>), lo cual es más intuitivo. 

echo match (1) {
    0 => 'Foo',
    1 => 'Bar',
    2 => 'Baz',
};
//> Bar

A través de

Si una sentencia switch no tiene una pausa después de cada caso, continuará con el siguiente caso aunque el código se rompa. Esto fue por diseño, para que las funciones de conmutación pudieran ejecutar varios bloques de código sucesivamente. Sin embargo, esto ha sido una fuente común de errores. 

Match ha implementado una ruptura implícita después de cada rama (=>). Ahora se pueden ejecutar múltiples condiciones colocando comas entre cada una de ellas: 

match ($x) {
    1, 2 => {
        // Same for 1 and 2
    },
    3, 4 => {
        if ($x === 3) {
            // Only 3
        }
        // Same for 3 and 4
    },
}

Expresiones de lanzamiento(rfc)

En PHP 8, la sentencia throw se ha convertido en una expresión. Esto significa que ahora, técnicamente, lanzar puede devolver un valor. Esto es útil en el sentido de que ahora se puede utilizar el lanzamiento en muchos más lugares, como las funciones de flecha o los operadores de coalescencia. 

Funciones de las flechas: 

$callable = fn() => throw new Exception();

Coalescencia de operadores: 

// $value is non-nullable.
$value = $nullableValue ?? throw new InvalidArgumentException();
 
// $value is truthy.
$value = $falsableValue ?: throw new InvalidArgumentException();

Operadores ternarios:

// $value is only set if the array is not empty.
$value = !empty($array)
    ? reset($array)
    : throw new InvalidArgumentException();

Tipo de retorno estático(rfc)

Como dice esta RFC, el tipo de retorno estático permite devolver el nombre de clase especial "static" desde un método: "El nombre de clase especial static en PHP se refiere a la clase sobre la que se ha llamado realmente a un método, incluso si el método es heredado. Esto se conoce como "unión estática tardía" (LSB). Esta RFC propone que static se pueda utilizar también como tipo de retorno (junto a los tipos self y parent ya utilizables)".

Sin embargo, en este caso no se puede utilizar estática como parte de un parámetro. El retorno estático hará referencia a la clase a la que se ha llamado. 

Tipos de unión(rfc)

Tipos de sindicatos te permiten declarar el tipo de valor que esperas de una entrada. En algunos idiomas se llama esquema. Esto se hace sintácticamente utilizando  | (por ejemplo string|array|int) están definidos. Pero la magia no acaba ahí, porque también puedes utilizar clases definidas como

class MyClass {

}
function myFunction(string|array|int|MyClass){

}

Los tipos de unión ya se utilizan en PHP. Sin embargo, se implementan utilizando el método de anotaciones phpdoc, como se muestra a continuación. 

class Number {
    /**
     * @var int|float $number
     */
    private $number;
 
    /**
     * @param int|float $number
     */
    public function setNumber($number) {
        $this->number = $number;
    }
 
    /**
     * @return int|float
     */
    public function getNumber() {
        return $this->number;
    }
}

Para obtener un poco más de contexto sobre el uso, consulta este ejemplo de la RFC:

class Number {
    private int|float $number;
 
    public function setNumber(int|float $number): void {
        $this->number = $number;
    }
 
    public function getNumber(): int|float {
        return $this->number;
    }
}

Todo esto se reduce al hecho de que puedes utilizar varios tipos de entrada para la misma función en lugar de uno solo, lo que permite un mayor grado de reutilización del código.

Tipos mixtos(rfc)

En versiones recientes de PHP, era posible declarar el tipo de datos de entrada y de retorno esperados. Sin embargo, PHP no siempre soportaba los tipos, y esto es un problema. En algunos casos, se omitió un Tipo o simplemente se olvidó.Tipos mixtos intenta ahora resolver este problema.

Un mixed sería el equivalente a array|bool|callable|int|float|null|object|resource|string

Aquí tienes un ejemplo de la documentación del RFC sobre cómo se utiliza:

// Valid example
 
class A
{
    public function foo(int $value) {}
}
 
class B extends A
{
    // Parameter type was widened from int to mixed, this is allowed
    public function foo(mixed $value) {}
}

Funciones adicionales de PHP 8

Hacer estable la clasificación(rfc)

La estabilidad se añade a todas las funciones que entran en el ámbito de Sort (por ejemplo.

sort, rsort, usort, asort, arsort, uasort, ksort, krsort, uksort, array_multisort).

Te recomiendo que lo leas en la documentación de RFC y lo compares con la aplicación tus , ya que el cambio de esta funcionalidad de ordenación inestable a estable podría afectar negativamente a tu código.

Promoción de la propiedad del constructor(rfc)

Esta función debería ayudar a acelerar tu flujo de trabajo de desarrollo y a reducir los errores. Actualmente, la definición de un objeto de valores requiere un conjunto de plantillas, como se muestra a continuación en la documentación de la RFC:

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;
    }
}

En este método, las propiedades deben repetirse tres veces. La mejora de esto es la breve fórmula que se indica a continuación: 

class Point {
    public function __construct(
        public float $x = 0.0,
        public float $y = 0.0,
        public float $z = 0.0,
    ) {}
}

Operador de seguridad cero(rfc)

¡Hay un nuevo operador en este bloque! 

Anstelle des klassischen <code>!== null</code> haben wir nun das bekommen: <code>?-></code>. Es scheint zunächst merkwürdig, aber wenn man es unter dem Gesichtspunkt der Verkettung von „if-Statements“ betrachtet, dann wird die Anwendung ziemlich deutlich: 

$country =  null;
 
if ($session !== null) {
    $user = $session->user;
 
    if ($user !== null) {
        $address = $user->getAddress();
 
        if ($address !== null) {
            $country = $address->country;
        }
    }
}
 
// do something with $country
$country = $session?->user?->getAddress()?->country;
 
// do something with $country

str_contiene(rfc)

Esta nueva y bonita función devuelve un valor booleano (verdadero/falso) cuando una cadena se encuentra en otra cadena. Toma dos argumentos, la cadena a buscar y la cadena a buscar.

str_contains('php8', '8'); // true
str_contains('php8', 'wordpress'); // false

Para obtener filtros de cadena aún más útiles, echa un vistazo a estas nuevas funciones:

str_starts_with('haystack', 'hay'); // true
str_ends_with('haystack', 'stack'); // true

Ambos devolverán un resultado booleano y funcionan de la misma manera que str_contains().

Mapas débiles(rfc)

En PHP, cuando estableces una variable con el valor de un objeto, normalmente se crea una referencia a ese objeto, pero no un nuevo objeto. 

Así que, en este caso, puedes acabar teniendo muchas referencias a un objeto, pero sólo un objeto. El problema con esto es: cuando llega el momento de eliminar este objeto, PHP cuenta el número de referencias que tiene este objeto. Y si hay más de uno, PHP se negará a eliminar ese objeto. 

Los mapas débiles resuelven este problema creando una referencia "débil" al objeto correspondiente. En cuanto se elimine el objeto, todas las variables con la referencia Weak Maps a este objeto se ponen a cero. 

Capturas no capturadas(rfc)

Un bloque try-catch ya es bastante impresionante en lo que respecta a la notificación de errores y ahora hay una forma aún más rápida de implementarlo. Y no, esto no afectará realmente a la legibilidad. 

La forma de la "vieja escuela" significaba que tenías que pasar tu Catch Exception a una variable como ésta:

function catchMeWhenIFall(){
	try {
        throw new Exception('NOPE - GRAVITY');
    } catch (Exception $e) {
        return $e->getMessage();
    }

}

Pero ahora no necesitas definir la variable que se pasará a tu bloque de captura.

try {
	throw new Exception('FOO!');
 catch  (){
	//Do some code here
 }

}

Más material de lectura sobre PHP 8

Si quieres saber más sobre el lanzamiento de PHP 8 o quieres comprobar los ejemplos de código RFC por ti mismo, sólo tienes que echar un vistazo al anuncio oficial del lanzamiento

"*"indica que los campos son obligatorios

Consentimiento*
Este campo es de validación y no debe modificarse.

¿Estás preparado para PHP 8? 

A ningún desarrollador le gustan las actualizaciones con grandes cambios (recordemos WordPress 5.0 y Gutenberg), en las que se corre el riesgo de que se rompa el código de tu y te esperen horas de trabajo o una reconstrucción completa. Sin embargo, si el código tu ya funcionaba correctamente con PHP 7.4, no deberías tener ningún problema con PHP 8 (más información sobre PHP y WordPress en el próximo capítulo). 

Sin embargo, si estás ejecutando una versión antigua de PHP, debes comprobar la lista de características obsoletas antes de actualizar. Consulta la documentación de los "Apéndices" de PHP para obtener una lista completa de las funciones anteriores, los cambios y los problemas al actualizar de una versión de PHP a la siguiente. 

¿Actualizar WordPress a PHP 8? 

Esta cita del"Informe de compatibilidad de WordPress y PHP 8" de Yoast ya sugiere que, como usuario de WordPress, no debes tratar la actualización a PHP 8 a la ligera. La conclusión del informe refuerza esta suposición, como escribe Omar Reiss: "Con sólo investigar un subconjunto de cambios de ruptura en PHP 8 ya pudimos confirmar que es probable que esto provoque una ruptura importante en los sitios con un origen poco claro de dicha ruptura. A menudo el error se produce en un lugar, pero es causado por un plugin o tema en un lugar diferente, lo que hace que estos problemas sean difíciles de depurar".

Estos problemas de compatibilidad fueron también la razón por la que PHP 8 no estuvo disponible inmediatamente para nuestros clientes. Especialmente después de las actualizaciones importantes, siempre tiene sentido dar a los desarrolladores de los plugins de WordPress el tiempo suficiente para realizar cualquier ajuste y esperar por el momento. Ahora puedes actualizar fácilmente tu sitio web a PHP 8 o PHP 8.1 a través de Raidboxes Dashboard tu . En este artículo del Centro de Ayuda se explica cómo probar correctamente una nueva versión de PHP en Raidboxes .

Nuestra conclusión sobre PHP 8

PHP 8 es un gran paso adelante respecto a sus predecesores. Aunque puede que no veas una mejora drástica en el rendimiento de forma inmediata (dependiendo de cómo utilices PHP 8), deberías considerar la actualización, al menos después de haberla probado, de que sea estable y de que esté disponible en tu host de WordPress. La nueva versión es una progresión natural, y si la implementas cuanto antes, estarás sentando una base sólida para futuras mejoras, crecimiento y rendimiento.

¿Más preguntas sobre PHP 8?

Espero que este artículo te haya servido para entender las nuevas y emocionantes características de PHP 8. ¿Tienes alguna otra pregunta sobre este tema? No dudes en utilizar la función de comentarios. ¿Quieres más consejos sobre WordPress, diseño web y más? Entonces síguenos en Twitter, Facebook o a través de nuestro Newsletter.

¿Te ha gustado el artículo?

Con tu valoración nos ayudas a mejorar aún más nuestro contenido.

Escribe un comentario

Tu dirección de correo electrónico no se publicará. Los campos obligatorios están marcados con *.