¿Qué hay de nuevo en PHP 7.3?

Desde el lanzamiento de PHP 7, se han visto una gran cantidad de nuevas funcionalidades que han mejorado notablemente la forma en la que los desarrolladores pueden usar PHP en sus proyectos. El objetivo principal de estas nuevas funciones es mejorar el rendimiento y la seguridad de las aplicaciones PHP.

 La nueva versión de PHP 7.3 viene con algunas actualizaciones muy necesarias.

En este post, explicaremos algunas de las funciones y actualizaciones de PHP 7.3 recientemente introducidas. Recuerda que desde el panel de gestión de tu alojamiento en DonDominio puedes cambiar la versión de PHP en cualquier momento.

Mejoras de PHP 7.3

• Sintaxis Heredoc y Nowdoc flexibles
• Permitir una coma final en las llamadas a funciones
• JSON_THROW_ON_ERROR
• Migración PCRE2
• list() Asignación de referencia
• Función is_countable
• array_key_first(), array_key_last()
• Mejoras de contraseñas Hash Argon2 
• Deprecada y eliminada image2wbmp()
• Deprecada y eliminada Case-Insensitive Constants
• Actualizaciones de FPM

Sintaxis Heredoc y Nowdoc flexibles

La sintaxis Heredoc y Nowdoc ayudan a los usuarios a utilizar cadenas largas de varias líneas. Requiere que el identificador final sea la primera cadena que aparece en una nueva línea.

// En vez de:

$query = <<<SQL
SELECT *
FROM `table`
WHERE `column` = true;
SQL;

// Puedes hacer esto:

$query = <<<SQL
   SELECT *
   FROM `table`
   WHERE `column` = true;
   SQL;

Básicamente esta actualización propone dos nuevos cambios que son los siguientes:

• Para habilitar el marcador de cierre
• Para eliminar el requisito de nueva línea después del marcador de cierre

En el ejemplo, mencionado anteriormente, puedes ver los dos cambios fácilmente.

Permitir una coma final en las llamadas a funciones

La adición de coma final se realiza al final de los parámetros, elementos y variables enumerados. Varias veces llamamos a una serie de elementos en un array o función (especialmente funciones variadic), en las que si se ha omitido una coma, generaran un error. Con el fin de evitar ese problema, la coma final puede ser útil. Desde PHP 7.2 se permite su uso en sintaxis de nombres agrupados.

use Foo\Bar\{
   Foo,
   Bar,
};

$foo = [
   'foo',
   'bar',
];

A medida que se agregan nuevos valores, las comas finales son muy útiles.

En funciones variadas como unset(), harán el trabajo adecuadamente:

unset(
   $foo,
   $bar,
   $baz,
);

Cuando envía una lista de variables a través de la función compact() a un motor de plantillas, también pueden usarse:

echo $twig->render(
   'index.html',
   compact(
       'title',
       'body',
       'comments',
   )
);

A menudo es necesario combinar arrays con la función array_merge() en situaciones donde se construye la concatenación o la agrupación de datos. Puedes usar coma final allí:

$newArray = array_merge(
   $arrayOne,
   $arrayTwo,
   ['foo', 'bar'],
);

De manera similar, puedes usarla en métodos, argumentos de funciones y llamadas de cierre.

class Foo
{
 public function __construct(...$args) {
   //
 }

 public function bar(...$args) {
   //
 }

 public function __invoke(...$args) {
   //
 }
}

$foo = new Foo(
 'constructor',
 'bar',
);

$foo->bar(
 'method',
 'bar',
);

$foo(
 'invoke',
 'bar',
);

JSON_THROW_ON_ERROR

Para parsear las respuestas JSON, tenemos dos funciones disponibles json_encode() y json_decode(). Lamentablemente, Json_encode() solo arrojará un error falso, mientras que json_decode arrojará un valor nulo, y ese valor puede ser verdadero. La única forma de saber el error es llamar a json_last_error() o json_last_error_msg(), que devuelven el estado de error global en formas legibles para máquina y humanos.

En esta RFC, la solución propuesta es agregar JSON_THROW_ON_ERROR en ambas funciones, lo que ignora el estado de error global. Si se produce un error, estas funciones lanzan una excepción JsonException con el mensaje y el código establecidos en cualquier json_last_error() y json_last_error_msg(). Puedes usarlo como:

json_encode($data, JSON_THROW_ON_ERROR);

json_decode("invalid json", null, 512, JSON_THROW_ON_ERROR);

Migración PCRE2

PHP usa PCRE para expresiones regulares. Desde PHP 7.3, PCRE2 entrará en acción. Por lo tanto, deberemos migrar las expresiones regulares existentes de acuerdo con las reglas de PCRE2. Estas reglas serán más agresivas que antes. Por ejemplo, la expresión regular:

preg_match('/[\w-.]+/', '');

Esta expresión regular fallará ahora y no generará un error de advertencia. Porque PCRE2 es estricto con respecto a mover el guión al final.

Estas y más características están disponibles con la actualización a PCRE2 10.x:

• Reenviar las referencias inversas relativas, \ g {+2} (reflejando el \ g {-2} existente)
• Verificación de versión disponible a través de patrones como (? (VERSIÓN> = x) …)
• (* NOTEMPTY) y (* NOTEMPTY_ATSTART) le dicen al motor que no devuelva coincidencias vacías)
• (* NO_JIT) deshabilita la optimización JIT
• (* LIMIT_HEAP = d) establece el límite de tamaño de almacenamiento dinámico en d kilobytes
• (* LIMIT_DEPTH = d) establece el límite de seguimiento en d
• (* LIMIT_MATCH = d) establece el límite de coincidencia en d

list() Asignación de referencia

PHP tiene funciones list() de asignación y referencia. Pero en el estado actual no puede usar la asignación de referencia en la función list(). De ahora en adelante, con PHP 7.3 se permitirá su uso. La nueva sintaxis mejorada es la siguiente:

$array = [1, 2];
list($a, &$b) = $array;

//Equivalente a 

$array = [1, 2];
$a = $array[0];
$b =& $array[1];

Los nuevos cambios en PHP 7.3 también nos permitirán usar esto con la listas anidadas y la función foreach():

$array = [[1, 2], [3, 4]];
foreach ($array as list(&$a, $b)) {
   $a = 7;
}
var_dump($array);

Función is_countable

En PHP 7.2, puedes contar objetos y matrices a través de la función count(). Si el objeto no es contable, PHP lanza una advertencia. Es necesario comprobar si el objeto o la variable es contable o no. Mientras que PHP 7.3 ahora tiene una nueva función is_countable() que retorna si la variable pasada es contable o no.

Este RFC propone una nueva función de tipo que devuelve verdadero si el valor dado es un tipo de matriz o una instancia de la interfaz contable.

Antes:

if (is_array($foo) || $foo instanceof Countable) {
   // $foo is countable
}

Después:

if (is_countable($foo)) {
   // $foo is countable
}

array_key_first(), array_key_last()

Actualmente, PHP permite recuperar la primera y última clave/valor del array al cambiar el estado interno de la matriz cuando se utilizan los métodos reset(), end() y key(). Ahora para evitar esta desorden en el estado interno, PHP 7.3 propone nuevas funciones y las agrega al núcleo:

• $ key = array_key_first ($ array); Para reunir la primera clave de la matriz
• $ key = array_key_last ($ array); Para reunir la última clave de la matriz
• $ valor = array_value_first ($ array); Para reunir el primer valor de la matriz
• $ valor = array_value_last ($ array); Para reunir el último valor de la matriz

Veamos el ejemplo:

// Uso de un array asociativo

$array = ['a' => 1, 'b' => 2, 'c' => 3];
$firstKey = array_key_first($array);
$lastKey = array_key_last($array);
assert($firstKey === 'a');
assert($lastKey === 'c');

// Uso de un array numerico

$array = [1 => 'a', 2 => 'b', 3 => 'c'];
$firstKey = array_key_first($array);
$lastKey = array_key_last($array);
assert($firstKey === 1);
assert($lastKey === 3);

Mejoras de contraseñas Hash Argon2 

En versiones anteriores de PHP, obtuvimos el hashing de contraseñas Argon2, que es un algoritmo moderno para asegurar contraseñas utilizando hashes. Se presenta en tres tipos diferentes, Argon2i, Argon2d y Argon 2id. Argon2i está optimizado para el hashing de contraseña y la derivación de clave basada en contraseña. Argon2d es más rápido y utiliza el acceso a la memoria en función de los datos. Argon2i en su lugar utiliza el acceso a la memoria independiente de datos. Argon2id es un híbrido de Argon2i y Argon2d, que utiliza una combinación de accesos de memoria-dependiente y de memoria-independiente de los datos.

password_hash():

Argon2id es ahora la variante recomendada de Argon2 para usar en las funciones paswword_ *.

// Argon2id por nombre con factores de coste personalizados se comporta igual que PASSWORD_ARGON2I

password_hash('password', PASSWORD_ARGON2ID, ['memory_cost' => 1<<17, 'time_cost' => 4, 'threads' => 2]);

password_verify();

La función password_verify () funciona con Argon2id además de Argon2i.

password_needs_rehash();

Esta función también aceptará el hash Argon2id y si los factores de coste cambian, esto se volverá verdadero.

$hash = password_hash('password', PASSWORD_ARGON2ID);
password_needs_rehash($hash, PASSWORD_ARGON2ID); // false
password_needs_rehash($hash, PASSWORD_ARGON2ID, ['memory_cost' => 1<<17]); // true

Deprecada y eliminada image2wbmp()

Esta función devuelve el formato de imagen de mapa de bits o WBMP. Otra función imagewbmp() también está disponible haciendo lo mismo que se supone para manejar la conversión monocromática necesaria. Por lo tanto, debido a la duplicación, image2wbmp() ahora está en desuso y en PHP7.3 se puede reemplazar con imagewbmp(). Después de la deprecación, cada llamada a image2wbmp() emitirá una advertencia desaprobación. Tras su eliminación, cada llamada a image2wbmp() generaría un error fatal.

Deprecada y eliminada Case-Insensitive Constants

En estos momentos, puedes utilizar constantes que distinguen entre mayúsculas y minúsculas y otras que no lo hacen. Pero las constantes insensibles a mayúsculas y minúsculas creaban complejidades de bits en el uso. Por lo tanto, para abordar esto, PHP 7.3 propone descartar constantes que no distinguen entre mayúsculas y minúsculas.

Actualmente, la situación es:

• Las constantes de clase siempre distinguen entre mayúsculas y minúsculas.
• Las constantes globales declaradas con const siempre distinguen entre mayúsculas y minúsculas.
• Las constantes declaradas con define() distinguen entre mayúsculas y minúsculas de forma predeterminada.
• Es posible declarar constantes que no distinguen entre mayúsculas y minúsculas al pasar verdadero como el tercer parámetro de define().

PHP 7.3 propone los siguientes cambios para solucionar esto:

• Deprecar la llamada a define() con el tercer parámetro como verdadero.
• Deprecar el acceso a una constante que no distingue entre mayúsculas y minúsculas con una cubierta distinta a la del sitio de declaración. Las constantes true, false y null están exentas de esto.

Actualizaciones a FPM

El administrador de procesos FastCGI tiene también una actualización y ahora viene con nuevas opciones para personalizar el registro de FPM.

log_limit: Configura la longitud permitida para los mensajes de registro. Este límite podría ser más de 1024 caracteres sin ajuste.

log_buffering: Permite el registro experimental sin búfer adicional.

Nota final

En este post hemos tratado algunos de los temas más importantes de PHP 7.3, si quieres ver toda la información sobre las actualizaciones puedes acceder a la página de php.net.

¿Buscas un alojamiento web?

Consulta nuestros planes: