Guía de PHP 7.4: Rendimiento, Funciones, Obsolescencias

Guía de PHP 7.4: Rendimiento, Funciones, Obsolescencias

¡PHP 7.4 finalmente ha llegado! Esta nueva versión, lanzada el 28 de noviembre de 2019, ahora está disponible en todos los servidores de Hostinger. Los desarrolladores pueden esperar mejoras en la legibilidad, el mantenimiento y la facilidad de uso del código. Veamos algunas de las nuevas funciones, ajustes de rendimiento y otras razones por las que deberías migrar a PHP 7.4.

¿Qué trae PHP 7.4 para ti?

PHP continúa evolucionando, al lanzar su última actualización PHP 7.4, llena de nuevas características. Como hemos visto en versiones anteriores de PHP 7, el rendimiento y la velocidad siguen mejorando. Una de las características nuevas más interesantes es la precarga. Ayuda a acelerar la ejecución de scripts, además de introducir la capacidad de tener un código más rápido y limpio, gracias a la simplificación de líneas de código comunes.

Las buenas personas responsables de PHP han escuchado los comentarios y solicitudes de su audiencia y los han respondido con toda su fuerza. Desde entonces, han estado cambiando continuamente el código para que sea más intuitivo y más fácil cambiar entre lenguajes de programación.

PHP se utiliza en más del 78,9% de todos los sitios web. Según W3techs, los sitios más populares que utilizan PHP son Wikipedia, Pinterest y Facebook, por nombrar algunos.

Si miramos específicamente los sitios de WordPress que ejecutan PHP, comparando PHP 5 y 7, podemos ver un aumento del doble de velocidad. Los sitios web impulsados ​​por WordPress definitivamente obtienen el máximo provecho al usar la última versión de PHP que existe. Los usuarios de Hostinger pueden optimizar sus sitios de WordPress a nuevos niveles con solo hacer clic en un botón.

Estadísticas de uso de PHP

¿Ves todas esas figuras geniales? El gráfico muestra algo de verdad sobre los sitios web que utilizan PHP de forma activa. ¿34,713,433 sitios web en vivo son suficientes para captar tu atención? Esa es la cantidad de personas que utilizan hosting PHP en este momento. Además, PHP 7.4 ya está funcionando mejor que PHP 7.,  con un rendimiento mejorado y otras mejoras para la calidad de vida.

El siguiente gráfico muestra la prueba comparativa general en versiones nuevas y antiguas de PHP. Algunos de los criterios probados fueron la facilidad de uso, la velocidad y el rendimiento, entre otros.

Media geométrica de PHP de todos los resultados

Cómo cambiar tu versión de PHP

¿Listo para actualizar? Seguro que sí, por eso Hostinger lo hace tan fácil como siempre con estos cuatro sencillos pasos. Estarás probando tu nueva y mejorada versión de PHP en poco tiempo.

  1. Inicia sesión en tu cuenta de Hostinger y presiona el botón Inicio.
  2. En tu página de inicio, desplázate hacia abajo hasta la sección Hosting y haz clic en el icono Administrar.
  3. En el cuadro de búsqueda, escribe Configuración de PHP y haz clic sobre la opción correspondiente.
  4. Selecciona PHP 7.4 y haz clic en Guardar.

Habilitando PHP 7.4 en Hostinger hPanel

¡Felicidades! Ahora tienes la mejor y más actualizada versión de PHP que existe.

Para verificar tu versión actual de PHP, todo lo que necesitas hacer es ir a la pestaña Hosting y verificar el panel lateral izquierdo para ver la versión de PHP. Si es menos de 7.4, sigue los pasos y actualízala.

¿Qué hay de nuevo en PHP 7.4?

Desde 2016, PHP7 ha estado lanzando actualizaciones anuales sin falta. Cada año ofrecen nuevas funciones, adiciones y la posibilidad de escribir un código más limpio, lo que hace que el lenguaje sea más confiable y fácil de usar para quienes lo ejecutan en sus sitios web.

Profundicemos y echemos un vistazo más de cerca a algunos de los cambios que se realizaron en la actualización de PHP 7.4. Para obtener una lista completa, consulta el registro de cambios aquí.

Precarga

Hablemos de código. Cuando utilizas un framework o bibliotecas, tus archivos deben cargarse y vincularse en cada solicitud. La precarga es cuando puedes cargar frameworks y bibliotecas en OPCache. Esta permite que el servidor cargue los archivos PHP, los almacene en la memoria durante el inicio y los tenga disponibles para futuras solicitudes. ¡Hablando de hacer que las cosas funcionen rápido!

La precarga se ejecuta mediante una directiva php.ini específica: opache.preload, que tiene el compilador de scripts PHP y se ejecuta cuando se inicia el servidor. También se puede utilizar para precargar más archivos y elegir incluirlos o compilarlos.

Esto es increíble; sin embargo, si alguna vez se cambia la fuente de los archivos precargados, el servidor debe reiniciarse. Los archivos precargados también permanecen almacenados en caché en la memoria OPCache para siempre.

Pero, estos archivos precargados seguirán estando disponibles para futuras solicitudes en caso de que necesites volver a utilizarlos.

Operador de propagación en expresiones de matriz

Cuando se lanzó PHP 5.6, PHP comenzó a admitir el desempaquetado de argumentos (operador de propagación) pero ahora, con la versión 7.4, podemos usar esta función con una expresión de matriz. El desempaquetado de argumentos es una sintaxis para descomprimir arrays y Traversables en listas de argumentos. Y, para hacerlo, solo necesita ir precedido por … (3 puntos). Eso es todo.

Veamos este ejemplo:

$animales = ['perro', 'gato'];
$animalkingdom = ['leon', 'elefante', ...$animales, 'jirafa'];
// Resultado: [‘leon’, ‘elefante’, ‘perro’, ‘gato’, ‘jirafa’];

Ahora podemos expandir una matriz desde cualquier lugar que queramos en otra matriz, simplemente usando la sintaxis del operador de propagación.

Aquí hay un ejemplo más extenso:

$num1 = [1, 2, 3];
$num2 = [...$num1]; // [1, 2, 3]
$num3 = [0, ...$num1]; // [0, 1, 2, 3]
$num4 = array(...$num1, ...$num2, 111); // [1, 2, 3, 1, 2, 3, 111]
$num5 = [...$num1, ...$num1]; // [1, 2, 3, 1, 2, 3]

No solo eso, sino que también puedes usarlo en una función. Mira este ejemplo:

function getNum() {
 return ['a', 'b'];
}
$num6 = [...getNum(), 'c']; // ['a', 'b', 'c']
$num7 = [...new NumIterator(['a', 'b', 'c'])]; // ['a', 'b', 'c']
function arrGen() {
   for($i = 11; $i < 15; $i++) {
       yield $i;
   }
}
$num8 = [...arrGen()]; // [11, 12, 13, 14]

Además, ahora puedes descomprimir matrices y generadores devueltos por una función directamente en una nueva matriz.

Un ejemplo de código se vería así:

function getAnimals(){
 return ['perro', 'gato', 'elefante'];
}
$num1 = [...getAnimals(), 'leon', 'tigre', 'jirafa'];

Y con PHP 7.4, imprimiría:

array(6) {
 [0]=>
 string(3) "perro"
 [1]=>
 string(3) "gato"
 [2]=>
 string(8) "elefante"
 [3]=>
 string(4) "leon"
 [4]=>
 string(5) "tigre"
 [5]=>
 string(7) "jirafa"
}

Con esta nueva expresión de matriz, los operadores de propagación deberían tener un rendimiento mucho mejor que el de 7.3 array_merge. Esto se debe a que el operador de propagación es una estructura de lenguaje, mientras que array_merge es una función. Además, porque el operador de propagación admite objetos que implementan traversable y array_merge solo admite matrices.

Algunas cosas importantes a tener en cuenta, solo puede usar matrices indexadas ya que las claves de cadena no son compatibles. Si los usas, verás un error recuperable en la pantalla, una vez que encuentre la clave de cadena.

Otro beneficio glorioso de la versión 7.4 es la eliminación de array_merge. ¡Dile adiós al temido cambio de índice!

Por ejemplo, veamos esta combinación de matriz larga y organizada a continuación:

$array = [‘banana, ‘naranja’];
$array[2] = ‘naranja’;
$array[1] = ‘manzana’; //shifting
var_dump($array);
// prints
array(3) {
 [0]=>
 string(6) "banana"
 [1]=>
 string(5) "manzana"
 [2]=>
 string(6) "naranja"

Otro beneficio de 7.4 es el uso de la función generadora. Una función generadora opera como una función normal, excepto que en lugar de devolver un valor, una función generadora produce tantos valores como sea necesario.

Analiza el código de ejemplo a continuación:

function generator() {
 for ($i = 3; $i <= 5; $i++) {
   yield $i;
 }
}
$num1 = [0, 1, 2, ...generator()];

Referencias débiles

Ahora PHP 7.4 tiene una clase WeakReference, que no debe confundirse con la clase WeakRed o la extensión Weakref.

WeakReferences permite al programador recordar una referencia a un objeto. Esto es útil porque no evita que el objeto sea destruido. Es ideal para implementar estructuras similares al caché.

WeakReference {
/* Metodos */
public __construct ( void )
public static create ( object $referent ) : WeakReference
public get ( void ) : ?object
}

Parámetros contravariantes y retornos covariantes

Actualmente, PHP utiliza principalmente tipos de parámetros y tipos de retorno invariantes. Es decir, si un método tiene un parámetro o tipo de retorno X, entonces el parámetro de subtipo o tipo de retorno también debe ser de tipo X.

Ahora, PHP 7.4 propone permitir covariantes (ordenados de específicos a genéricos) y contravariantes (invirtiendo el orden) en los tipos de parámetros y retornos.

A continuación, se muestra un ejemplo de ambos:

Ejemplo de tipo de retorno covariante:

interface Factory {
 function make(): object;
}
class UserFactory implements Factory {
 function make(): User;
}

Ejemplo de tipo de parámetro contravariante:

interface Concatable {
 function concat(Iterator $input);
}
class Collection implements Concatable {
// accepta todos los iterables, not solo Iterator
 function concat(iterable $input) {/* . . . */}
}

Tipos de Propiedades 2.0

Desde PHP 5, las sugerencias de tipos han sido una característica disponible que te permite especificar el tipo de variable que se espera que se pase a una función o clase. En las migraciones de PHP 7.2, la adición del tipo de datos object dio esperanzas de que habría más de este estilo disponibles en el futuro. El futuro es ahora.

En el nuevo 7.4, PHP puede admitir la siguiente lista de tipos:

bool, int, float, string, array, object, iterable, self, parent
any class or interface name
?type // donde "type" puede ser cualquiera de las anteriores

Toma en cuenta que el tipo parent se puede utilizar en clases y no es necesario que tenga un parent coherente con el parámetro y el tipo de retorno.

Además, toma en cuenta que no se admiten void ni callable. Se eliminó void porque no era útil y tenía una semántica poco clara; Callable, porque su comportamiento dependía del contexto.

Veamos algunos ejemplos más.

Aquí hay una clase, escrita para PHP 7.3:

class User {
   /** @var int $id */
   private $id;
   /** @var string $name */
   private $name;
   public function __construct(int $id, string $name) {
       $this->id = $id;
       $this->name = $name;
   }
   public function getId(): int {
       return $this->id;
   }
   public function setId(int $id): void {
       $this->id = $id;
   }
   public function getName(): string {
       return $this->name;
   }
   public function setName(string $name): void {
       $this->name = $name;
   }
}

En PHP 7.4, sin sacrificar ningún tipo de seguridad, una clase ahora se puede escribir tan simple como:

class User {
   public int $id;
   public string $name;
   public function __construct(int $id, string $name) {
       $this->id = $id;
       $this->name = $name;
   }
}

A continuación, se muestran algunos ejemplos de todos los tipos que ahora admite la versión 7.4:

class Example {
    public int $scalarType;
   protected ClassName $classType;
   private ?ClassName $nullableClassType;
  // Types are also legal on static properties
   public static iterable $staticProp;
  // Types can also be used with the "var" notation
   var bool $flag;
  // Typed properties may have default values (more below)
   public string $str = "foo";
   public ?string $nullableStr = null;
  // The type applies to all properties in one declaration
   public float $x, $y;
  // equivalent to:
   public float $x;
   public float $y;
}

Funciones de flecha (arrow) 2.0

Las funciones anónimas en PHP tienden a ser extensas, incluso cuando sólo realizan operaciones simples. Esto se debe en parte a una gran cantidad de texto repetitivo sintáctico y en parte a la necesidad de importar manualmente las variables utilizadas.

Esto hace que el código que utiliza cierres simples sea confuso de leer e incluso más difícil de entender.

Veamos un código que usarías con PHP 7.3:

function array_values_from_keys($arr, $keys) {
   return array_map(function ($x) use ($arr) { return $arr[$x]; }, $keys);
}

Ahora, así se vería la sintaxis más concisa con PHP 7.4:

function array_values_from_keys($arr, $keys) {
   return array_map(fn($x) => $arr[$x], $keys);
}

Así que, las funciones de flecha (arrow) ahora tienen esta forma simple:

fn(parameter_list) => expr

A continuación puedes ver un ejemplo de dos funciones $fn1 (7.3) y $fn2 (7.4) una debajo de la otra. Tienen el mismo resultado pero se ven diferentes:

$y = 1;
$fn1 = fn($x) => $x + $y;
$fn2 = function ($x) use ($y)
{
   return $x + $y;
};

Esto también funcionará si las funciones de flecha están anidadas:

$z = 1;
$fn = fn($x) => fn($y) => $x * $y + $z;

Aquí la función externa captura $z. Entonces, la función interna también captura $z de la función externa. Con 7.4, el alcance externo puede estar disponible en la función interna. Esto es algo que en la versión 7.3 no se podía hacer.

La sintaxis de la función de flecha permite una variedad de funciones tales como variables, valores predeterminados, parámetros y tipos de retorno, así como el paso y retorno por referencia. Todo mientras mantiene un aspecto limpio y legible. A continuación se muestran todas las funciones válidas de flecha ahora disponibles:

fn(array $x) => $x;
fn(): int => $x;
fn($x = 42) => $x;
fn(&$x) => $x;
fn&($x) => $x;
fn($x, ...$rest) => $rest;

Una cosa a tener en cuenta es que las funciones de flecha tienen la precedencia más baja. Chequea el siguiente ejemplo:

fn($x) => $x + $y
// no
fn($x) => ($x + $y)
// es
(fn($x) => $x) + $y

Obsolescencias

Muchas funciones están quedando obsoletas con la fusión a la versión 7.4. La siguiente lista es una breve descripción general de las funciones destinadas a quedar obsoletas. Puedes encontrar una explicación más detallada aquí:

  • El tipo real
  • Legado de citas mágicas
  • array_key_exists() con objetos
  • Filtro FILTER_SANITIZE_MAGIC_QUOTES
  • Método export()
  • mb_strrpos() con codificación como tercer argumento
  • Mezcla de orden de parámetros implode()
  • Desvinculando $this de cierres no estáticos
  • función hebrevc()
  • función convert_cyr_string()
  • función money_format()
  • función ezmlm_hash()
  • función restore_include_path()
  • allow_url_include ini directiv

Algunas funciones importantes que quedarán obsoletas a tener en cuenta son las siguientes de dos pasos.

Cambio de la precedencia de un operador de concatenación

Actualmente, la precedencia de los operadores «.», «+» y «-» es igual. Cualquier combinación de estos operadores simplemente se resolverá de izquierda a derecha.

Veamos este código en PHP 7.3:

echo "sum: " . $a + $b;
// se evaluaría de izquierda a derecha
echo ("sum: " . $a) + $b;
// También podría verse así

Con PHP 7.4, «+» y «-» tendrían prioridad sobre «.» Por lo que las sumas y restas siempre se realizarían antes de la cadena. Esto tendría el siguiente aspecto:

echo "sum: " . $a + $b;
// se ejecutaría como si el código fuera el siguiente.
echo "sum :" . ($a + $b);

Esta propuesta de dos pasos pretende ser menos propensa a errores y más instintiva. PHP 7.4 se encuentra actualmente en la primera etapa con un aviso de desaprobación de las expresiones sin paréntesis de «+», «-» y «.» Mientras se espera que ocurra el voto/cambio final en PHP 8.

Operador ternario asociativo de izquierda

A diferencia de la mayoría de los otros lenguajes, el operador ternario en PHP es asociativo por la izquierda en lugar de asociativo por la derecha. No solo es poco común, también es confuso para los programadores que cambian entre diferentes idiomas. PHP 7.4 propone eliminar la asociatividad izquierda y requiere el uso de paréntesis en su lugar.

Echemos un vistazo al código a continuación:

return $a == 1 ? 'one'
    : $a == 2 ? 'two'
    : $a == 3 ? 'three'
    : $a == 4 ? 'four'
              : 'other';

En la mayoría de los demás idiomas se interpretaría como:

return $a == 1 ? 'one'
    : ($a == 2 ? 'two'
    : ($a == 3 ? 'three'
    : ($a == 4 ? 'four'
              : 'other')))

Mientras que en PHP, en cambio, se interpreta como:

return ((($a == 1 ? 'one'
    : $a == 2) ? 'two'
    : $a == 3) ? 'three'
    : $a == 4) ? 'four'
              : 'other';

Esto puede generar errores porque, por lo general, no es lo que se pretendía.

A través de una propuesta separada de dos pasos, PHP 7.4 ha implementado el uso explícito de paréntesis como una advertencia de obsolescencia y es de esperar que lleve a cabo un error de tiempo de ejecución de compilación en versiones futuras.

Conclusión

Justo a tiempo para las vacaciones, PHP 7.4 trae nuevas funciones y mejoras en la calidad de vida para todos los desarrolladores de PHP.

Los sitios web de WordPress definitivamente se beneficiarán de estas mejoras y sus usuarios pueden esperar tiempos de ejecución más rápidos y menos uso de memoria al usar PHP 7.4, en comparación con versiones anteriores.

Con la adición de declaraciones de tipo de propiedad de primera clase y sugerencias de tipo, funciones de combinación de flechas y una velocidad ridículamente mejorada, la versión 7.4 seguramente mejorará tanto la velocidad como la calidad de tu flujo de trabajo.

Author
El autor

Deyimar A.

Deyi es una entusiasta del marketing digital, con experiencia en diseño de páginas web, creación de contenido, copywrite y SEO. Forma parte del equipo de SEO & Localization de Hostinger. En su tiempo libre, le gusta desarrollar proyectos, leer un libro o ver una buena película.