PHP 5.6.0 released

Características nuevas

Expresiones escalares constantes

Ahora es posible proporcionar una expresión escalar que involucre literales numéricos y de string y/o constantes en contextos donde PHP anteriormente demandaba un valor estático, tal como una constante, una declaración de una propiedad o argumentos de funciones predeterminados.

<?php
const UNO 1;
const 
DOS UNO 2;

class 
{
    const 
TRES DOS 1;
    const 
UN_TERCIO UNO self::TRES;
    const 
SENTENCE 'El valor de TRES es '.self::TRES;

    public function 
f($a UNO self::TRES) {
        return 
$a;
    }
}

echo (new 
C)->f()."\n";
echo 
C::SENTENCE;
?>

El resultado del ejemplo sería:

4
El valor de TRES es 3

Funciones variádicas mediante ...

Las funciones variádicas ahora se pueden implementar usando el operador ..., en lugar de depender de func_get_args().

<?php
function f($requerido$opcional null, ...$parámetros) {
    
// $parámetros es un array que contiene los argumentos restantes.
    
printf('$requerido: %d; $opcional: %d; número de parámetros: %d'."\n",
           
$requerido$opcionalcount($parámetros));
}

f(1);
f(12);
f(123);
f(1234);
f(12345);
?>

El resultado del ejemplo sería:

$requerido: 1; $opcional: 0; número de parámetros: 0
$requerido: 1; $opcional: 2; número de parámetros: 0
$requerido: 1; $opcional: 2; número de parámetros: 1
$requerido: 1; $opcional: 2; número de parámetros: 2
$requerido: 1; $opcional: 2; número de parámetros: 3

Desempaquetar argumentos mediante ...

Los array y los objetos Traversable se pueden desempaquetar a listas de argumentos al invocar a funciones emleando el opeardor .... A esto también se le conoce como el operador 'splat' en otros lenguajes como Ruby.

<?php
function sumar($a$b$c) {
    return 
$a $b $c;
}

$operadoes = [23];
echo 
sumar(1, ...$operadoes);
?>

El resultado del ejemplo sería:

6

Exponenciación mediante **

Se a añadido un operador asociativo derecho, **, para realizar la exponenciación, junto con un operador de asignación abreviado, **=.

<?php
printf
("2 ** 3 ==      %d\n"** 3);
printf("2 ** 3 ** 2 == %d\n"** ** 2);

$a 2;
$a **= 3;
printf("a ==           %d\n"$a);
?>

El resultado del ejemplo sería:

2 ** 3 ==      8
2 ** 3 ** 2 == 512
a ==           8

use function y use const

El operador use se ha ampliado para admitir funciones de importación y constantes además de clases. Esto se lleva a cabo mediante los contructores use function y use const, respectivamente.

<?php
namespace Espacio\De\Nombres {
    const 
FOO 42;
    function 
f() { echo __FUNCTION__."\n"; }
}

namespace {
    use const 
Espacio\De\Nombres\FOO;
    use function 
Espacio\De\Nombres\f;

    echo 
FOO."\n";
    
f();
}
?>

El resultado del ejemplo sería:

42
Espacio\De\Nombres\f

phpdbg

PHP ahora incluye un depurador interactivo llamado phpdbg, implementado como un módulo de SAPI. Para más información, visite la » documentación de phpdbg.

Codificación de caracteres predeterminada

default_charset ahora se emplea como conjunto de caracteres predeterminado para funciones que emplean una codificación específica, como htmlspecialchars(). Observe que si los ajustes de codificación iconv y mbstring (ahora obsoletos) están establecidos, tomarán precedencia sobre default_charset.

El valor predeterminado para este ajuste es UTF-8.

php://input es reutilizable

php://input ahora podría se reabierto y leído tantas veces como sea neceario. Este trabajo también ha resultado en una mayor reducción de la cantidad de memoria necesaria para tratar con datos POST.

Subidas de ficheros grandes

Ahora se admiten subidas de ficheros de más de 2 gigabytes.

GMP soporta la sobrecarga de operadores

Los objetos GMP ahora soportan la sobrecarga de operadores y la conversión a tipos escalares. Esto permite código más expresivo empleando GMP:

<?php
$a 
gmp_init(42);
$b gmp_init(17);

// Código pre-5.6:
var_dump(gmp_add($a$b));
var_dump(gmp_add($a17));
var_dump(gmp_add(42$b));

// Código nuevo:
var_dump($a $b);
var_dump($a 17);
var_dump(42 $b);
?>

hash_equals() para comparar string con seguridad contra ataques de temporización

Se ha añadido la función hash_equals() para comparar dos string en tiempo constante. Esto debería emplearse para mitigar los ataques de temporización; por ejemplo, al probar los hash de contraseñas de crypt() (asumiendo que no se puede usar password_hash() y password_verify(), que no son susceptibles a ataques de temporización).

<?php
$previsto   
crypt('12345''$2a$07$usesomesillystringforsalt$');
$correcto   crypt('12345''$2a$07$usesomesillystringforsalt$');
$incorrecto crypt('1234',  '$2a$07$usesomesillystringforsalt$');

var_dump(hash_equals($previsto$correcto));
var_dump(hash_equals($previsto$incorrecto));
?>

El resultado del ejemplo sería:

bool(true)
bool(false)

Algoritmo de hash gost-crypto

Se ha añadido el algoritmo de hash gost-crypto. Implementa la función de hash GOST usando las tablas S-box de CryptoPro, como se especifica en la » RFC 4357, sección 11.2.

Mejoras en SSL/TLS

Se han realizado un amplio rango de mejoras al soporte para SSL/TLS en PHP 5.6. Estas incluyen la habilitación de la verificación del par por omisión, el soporte para la comparación de huellas digitales de certificados, la mitigación de ataques de renegociación TLS, y muchas opciones de contexto SSL nuevas para permitir un mayor cotrol de grano fino en ajustes de protocolos y verificacioines al emplear flujos encriptados.

Estos cambios están descritos con más detalle en la sección Cambios de OpenSSL en PHP 5.6.x de esta guía de migración.

Soporte para pgsql asíncrono

La extensión pgsql ahora admite conexiones y consultas asíncronas, habilitando así un comportamiento de no bloqueo al interactuar con bases de datos de PostgreSQL. Las conexiones asíncronas podrían esteblecerse mediante la constante PGSQL_CONNECT_ASYNC, y se podrían emplear las nuevas funciones pg_connect_poll(), pg_socket(), pg_consume_input() y pg_flush() para manejar conexiones y consultas asíncronas.

add a note add a note

User Contributed Notes 4 notes

up
100
tr0y
7 months ago
It is also possible ( in 5.6.0alpha ) to typehint the ...-operator

function foo (stdclass ... $inbound) {
   var_dump($inbound);
}

// ok:
foo( (object)['foo' => 'bar'], (object)['bar' => 'foo'] );

// fails:
foo( 1, 2, 3, 4 );
up
24
ashnazg at php dot net
4 months ago
Note the order of operations in that exponentiation operator, as it was opposite of what my first expectation was:

<?php
// what I had expected,
// evaluating left to right,
// since no parens were used to guide the order of operations
2 ** 3 ** 2 == 64; // (2 ** 3) ** 2 = 8 ** 2 = 64

// the given example,
// which appears to evaluate right to left
2 ** 3 ** 2 == 512; // 2 ** (3 ** 2) = 2 ** 9 = 512
?>
up
7
Anonymous
1 month ago
Remember, that

    ($a ** $b) ** $c === $a ** ($b * $c)

Thats why exponent operator** is RIGHT associative.
up
10
gmblar+php at gmail dot com
7 months ago
<?php

function array_zip(...$arrays) {
    return
array_merge(...array_map(NULL, ...$arrays));
}

$a = array(1, 4, 7);
$b = array(2, 5, 8);
$c = array(3, 6, 9);

var_dump(implode(', ', array_zip($a, $b, $c)));

// Output
string(25) "1, 2, 3, 4, 5, 6, 7, 8, 9"
To Top