Un vistazo a PHP-5.6

Esta es la entrada 2 de 3 en la serie: PHP nuevas características

Un vistazo a PHP-5.6
PHP no es un lenguaje que ha quedado en el olvido ni abandonado, al contrario está en constante evolución y así lo ha demostrado su equipo de desarrollo con las últimas versiones liberadas y prueba fehaciente es la version 5.6 ya que incorpora novedosas características que facilitan nuestro trabajo a la hora de desarrollar nuestras aplicaciones. Dentro de estas nuevas funcionalidades podemos mencionar:

  • Definición de constantes mejorada
  • Funciones variádicas / Introducción del operador
  • Introducción del operador de exponenciación **
  • Desempaquetador de argumentos mediante el operador
  • Mayor flexibilidad al usar la palabra clave use
  • Depurador interactivo: phpdbg
  • Otras

Definición de constantes mejorada

Ahora las constantes soportan expresiones que involucren escalares, valores númericos, cadenas, constantes y arreglos.

Definición de constante que involucra a otra constante con operaciones númericas

const UNO = 1;
const DOS = UNO * 2; // Esto no es posible antes de la versión 5.6
// Imprime 2;
echo DOS, '
';

Definición de constante de clases que involucran constantes globales, constantes amigas (constantes definidas en la misma clase), operaciones con escalares, operaciones de cadenas.

class C {
    const TRES = DOS + 1;
    const UN_TERCIO = UNO / self::TRES;
    const LIBRE = 'Libre';
    const LIBRE_BYTE = self::LIBRE . 'Byte';
}
// Imprime 3;
echo C::TRES,  '
'; // Imprime 0.3333... echo C::UN_TERCIO, '
'; // Imprime LibreByte echo C::LIBRE_BYTE, '
';

Ahora es posible definir arreglos de constantes que a su vez involucre a otras constantes y a otros arreglos de constantes

/** Arreglo de constantes */
const ARR = ['A', 'B', 'C'];
/** Arreglo múltiple de constantes */
const MULTI_ARR = [[1,2], ['A', 'B'], 'C'];
/** Arreglo de constantes que involucra a otro arreglo de constante y a una constante de clase */
const MIX_ARR = [ARR, C::LIBRE_BYTE];
// Imprime B
echo ARR[1], '
'; // Imprime 2 echo MULTI_ARR[0][1]; // Imprime LibreByte echo MIX_ARR[1];

Funciones variádicas

Las funciones variádicas son aquellas funciones que soportan un número variable de argumentos. Antes de PHP-5.6 esto se lograba haciendo uso de las funciones func_num_args(), func_get_arg(), y func_get_args(), con la salida de PHP-5.6 se puede usar el operador para indicar que la función soporta un número variable de argumentos.

Por ejemplo si quisieramos calcular el average de un pelotero podemos hacerlo con la siguiente función

function avg(...$veces_al_bate) {
     return (array_sum($veces_al_bate) / count($veces_al_bate)) * 1000;
}
// Imprime 300
echo avg(1, 0, 1, 0, 0, 0, 0, 1, 0, 0);

Antes de PHP-5.6 lo haríamos de la siguiente manera:

function avg() {
     return (array_sum(func_get_args()) / func_num_args()) * 1000;
}
// Imprime 300
echo avg(1, 0, 1, 0, 0, 0, 0, 1, 0, 0);

También es posible especificar argumentos antes del operador . En este caso, solamente los argumentos que no coincidan con los argumentos especificados serán añadidos al array generado por el operador . Si antes del operador especificas un “hint” o tipo entonces todos los argumentos capturados por deben ser del tipo especificado o si no se genera un “fatal error”. Por ejemplo queremos implementar una función que permita formatear una o varias fechas a la vez entonces tendríamos algo asi:

function fmt_fechas($format, DateTime ...$dates) {
    // array_map recorre los elementos del arreglo y le aplica la
    // función especifícada
    return array_map(function ($date) use ($format) {
        return $date->format($format);	
    }, $dates);
}
// Imprime:
// { [0]=> string(10) "2015-07-03" [1]=> string(10) "2015-07-03" [2]=> string(10) "2015-07-03" }
var_dump(fmt_fechas('Y-m-d', new DateTime(), new DateTime('-3 days'),  new DateTime('+1 month')));
// Imprime:
// Catchable fatal error: Argument 4 passed to fmt_fechas() must be an instance of DateTime, null given...
fmt_fechas('Y-m-d', new DateTime(), new DateTime('-3 days'), null);

Introducción del operador de exponenciación **

Ahora es posible calcular la potencia de un número usando el operador ** para calcular 2 a la 8, haríamos lo siguiente:

// Imprime 256
echo 2 ** 8;

El operado ** tiene asociado el operador corto **=

$a = 2 ** 1;
$a **= 8;
// Imprime 256
echo $a, '
';

Desempaquetador de argumentos mediante el operador …

También es posible usar el operador para convertir un array o variable Traversable o literal en una lista de argumentos. Esta nueva funcionalidad particularmente me gusta mucho pues antes de PHP-5.6 si teníamos un arreglo de valores y queríamos pasarlos como parámetros primero debíamos desreferenciar el arreglo.

Antes de PHP-5.6:

function sumar($a, $b) {
    return $a + $b;
}
$a = [1, 2];
// Desreferenciamos el arreglo
// Imprime 3
echo sumar($a[0], $a[1]), '<br/>';

A partir de PHP-5.6 bastaría:

function sumar($a, $b) {
    return $a + $b;
}

// Imprime 3
echo sumar(...[1, 2]), '
'; $a = [1, 2]; // Imprime 3 echo sumar(...$a), '
';

Mayor flexibilidad al usar la palabra clave use

A partir de PHP-5.6 es posible importar constantes y funciones específicas de un espacio de nombre haciendo uso de las construcciones: use const, use function, si tenemos la siguiente definición de espacio de nombre.

namespace Mi\Espacio\DeNombre 
{
    const MI_CONSTANTE = 'MI_CONSTANTE';
    function miFuncion() 
    { 
    	echo __FUNCTION__, '
'; } }

Podemos importar MI_CONSTANTE y miFuncion con la siguiente definición:

namespace Cliente {
    use const Mi\Espacio\DeNombre\MI_CONSTANTE;
    use function Mi\Espacio\DeNombre\miFuncion;
 
    // Imprime: MI_CONSTANTE
    echo MI_CONSTANTE, '
'; // Imprime: Mi\Espacio\DeNombre\miFuncion miFuncion(); }

Depurador interactivo phpdbg

PHP-5.6 incluye un depurador interactivo llamado phpdbg implementado como un módulo SAPI, phpdbg permite control total del ambiente sobre el cual se ejecuta sin que esto repercuta en la funcionalidad y en el rendmiento del código depurado. Para mas información ver la documentación de phpdbg.

Codificación por defecto

Ahora las funciones htmlentities(), html_entity_decode(), htmlspecialchars() usan por defecto el valor asignado a la directiva: default_charset

Soporte para ficheros grandes

Ahora es posible subir ficheros de más 2 gigabytes

Para ver todo lo nuevo que trae PHP-5.6 remítase a: Nuevas características de PHP-5.5

Características obsoletas

– Llamada desde un contexto incompatible. Los métodos llamados desde un contexto incompatible ahora están obsoletos, generando errores E_DEPRECATED en lugar de E_STRICT. En futuras versiónes de PHP se eliminará las llamadas a métodos desde contextos incompatibles.

class A 
{
    function funcionA() 
    { 
        echo A::class; 
    }
}

class B 
{
    function funcionB() 
    { 
        A::funcionA(); 
    }
}

(new B)->funcionB();

Nótese que se está llamando de forma estática a la funcionA (que no ha sido declarada como estática) de la clase A desde una instancia de la clase B por tanto los contextos no son compatibles y se generaía el siguiente mensaje de error de nivel: E_DEPRECATED

Deprecated: Non-static method A::funcionA() should not be called statically, 
assuming $this from incompatible context in ...

Si hicieramos la llamada de la siguiente manera:

B::funcionB();

Se generaría el siguiente mensaje de error de nivel: E_STRICT

Strict Standards: Non-static method B::funcionB() should not be called statically ...

Strict Standards: Non-static method A::funcionA() should not be called statically ...

La variable global $HTTP_RAW_POST_DATA ha quedado obsoleta y se exhorta usar php://input en lugar de $HTTP_RAW_POST_DATA

La directiva always_populate_raw_post_data emitirá un mensaje de error nivel E_DEPRECATED siempre que la variable $HTTP_RAW_POST_DATA reciba un valor. $HTTP_RAW_POST_DATA tomará valor siempre que always_populate_raw_post_data = 1 o cuando el MIME type de los datos recibidos es desconocido.

Las opciones de configuración de iconv y mbstring relacionadas con la codificación han quedado obsoletas y se exhorta el uso de de default_charset

Otros cambios en PHP-5.6




Dejar un comentario

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