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 C {
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
Ahora también es posible definir un array constante utilizando la palabra reservada const:
<?php
const ARR = ['a', 'b'];
echo ARR[0];
?>
El resultado del ejemplo sería:
a
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, $opcional, count($parámetros));
}
f(1);
f(1, 2);
f(1, 2, 3);
f(1, 2, 3, 4);
f(1, 2, 3, 4, 5);
?>
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
Los array y los objetos Traversable se pueden desempaquetar a listas de argumentos al invocar a funciones empleando el operador .... 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;
}
$operadores = [2, 3];
echo sumar(1, ...$operadores);
?>
El resultado del ejemplo sería:
6
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", 2 ** 3);
printf("2 ** 3 ** 2 == %d\n", 2 ** 3 ** 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
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
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.
default_charset ahora se emplea como conjunto de caracteres predeterminado para las funciones htmlentities(), html_entity_decode() y htmlspecialchars(). Observe que si los ajustes de codificación iconv y mbstring (ahora obsoletos) están establecidos, tomarán precedencia sobre default_charset para las funciones de iconv y mbstring, respectivamente.
El valor predeterminado para este ajuste es UTF-8.
php://input ahora podría se reabierto y leído tantas veces como sea necesario. Este trabajo también ha resultado en una mayor reducción de la cantidad de memoria necesaria para tratar con datos POST.
Ahora se admiten subidas de ficheros de más de 2 gigabytes.
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);
if (version_compare(PHP_VERSION, '5.6', '<')) {
echo gmp_intval(gmp_add($a, $b)), PHP_EOL;
echo gmp_intval(gmp_add($a, 17)), PHP_EOL;
echo gmp_intval(gmp_add(42, $b)), PHP_EOL;
} else {
echo $a + $b, PHP_EOL;
echo $a + 17, PHP_EOL;
echo 42 + $b, PHP_EOL;
}
?>
El resultado del ejemplo sería:
59 59 59
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)
El método mágico __debugInfo() se ha añadido para permitir a los objetos cambiar las propiedades y los valores que se muestran cuando el objeto se imprime al utilizar var_dump().
<?php
class C {
private $prop;
public function __construct($val) {
$this->prop = $val;
}
public function __debugInfo() {
return [
'propSquared' => $this->prop ** 2,
];
}
}
var_dump(new C(42));
?>
El resultado del ejemplo sería:
object(C)#1 (1) {
["propSquared"]=>
int(1764)
}
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.
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 control de grano fino en ajustes de protocolos y verificaciones 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.
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.