Ahora es posible proporcionar una expresión escalar que involucre números, literales de tipo string y/o constantes en contextos donde anteriormente PHP esperaba un valor estático, tales como declaraciones de constantes o propiedades y argumentos predeterminados de funciones.
<?php
const UNO = 1;
const DOS = UNO * 2;
class C {
const TRES = DOS + 1;
const UN_TERCIO = UNO / self::TRES;
const RESULTADO = 'El valor de TRES es '.self::TRES;
public function f($a = UNO + self::TRES) {
return $a;
}
}
echo (new C)->f()."\n";
echo C::RESULTADO;
?>El ejemplo anterior mostrará:
4 El valor de TRES es 3
También es posible definir una constante array usando la
palabra clave const:
<?php
const ARR = ['a', 'b'];
echo ARR[0];
?>El ejemplo anterior mostrará:
a
...
Las funciones variádicas
ahora se pueden implementar usando el operador de descomposición ...,
en lugar de usar la función func_get_args().
<?php
function f($req, $opt = null, ...$params) {
// $params es un array que contiene los argumentos restantes.
printf('$req: %d; $opt: %d; Número de argumentos: %d'."\n",
$req, $opt, count($params));
}
f(1);
f(1, 2);
f(1, 2, 3);
f(1, 2, 3, 4);
f(1, 2, 3, 4, 5);
?>El ejemplo anterior mostrará:
$req: 1; $opt: 0; Número de argumentos: 0 $req: 1; $opt: 2; Número de argumentos: 0 $req: 1; $opt: 2; Número de argumentos: 1 $req: 1; $opt: 2; Número de argumentos: 2 $req: 1; $opt: 2; Número de argumentos: 3
...
Los arrays y los objetos
Traversable se pueden desempaquetar
en la lista de argumentos al llamar a una función usando el operador de
descomposición .... Este método es conocido como el
operador splat en otros lenguajes como Ruby.
<?php
function add($a, $b, $c) {
return $a + $b + $c;
}
$operators = [2, 3];
echo add(1, ...$operators);
?>El ejemplo anterior mostrará:
6
**
Se ha añadido un operador ** asociativo a la derecha
para soportar la exponenciación, en conjunción con el operador de
asignación **=.
<?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 ejemplo anterior mostrará:
2 ** 3 == 8 2 ** 3 ** 2 == 512 a == 8
use function y use const
El operador
use
se ha extendido para admitir la importación de funciones y constantes,
además de clases. Esto se hace usando las construcciones
use function y use const, respectivamente.
<?php
namespace Name\Space {
const FOO = 42;
function f() { echo __FUNCTION__."\n"; }
}
namespace {
use const Name\Space\FOO;
use function Name\Space\f;
echo FOO."\n";
f();
}
?>El ejemplo anterior mostrará:
42 Name\Space\f
PHP ahora incluye un depurador interactivo llamado phpdbg, implementado como un módulo SAPI. Para obtener más información, véase la documentación de phpdbg.
default_charset ahora se usa como el conjunto de caracteres predeterminado para las funciones htmlentities(), html_entity_decode() y htmlspecialchars(). Se debe tener en cuenta que si las configuraciones de codificación (ahora obsoletas) de iconv y mbstring están definidas, estas tendrán prioridad sobre la configuración de default_charset para las funciones iconv y mbstring, respectivamente.
El valor predeterminado para esta configuración es UTF-8.
php://input es reutilizable
php://input
ahora se puede volver a abrir y leer tantas veces como sea necesario.
Este nuevo mecanismo también ha permitido reducir significativamente la
cantidad de memoria requerida durante las operaciones POST.
Ahora se aceptan archivos de más de 2 Gigabytes.
Los objetos GMP ahora soportan la sobrecarga de operadores y el cambio de tipo a tipos escalares. Esto permite un código más expresivo usando 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 ejemplo anterior mostrará:
59 59 59
Se ha añadido la función hash_equals() para comparar dos string en tiempo constante. Esto debería usarse para evitar ataques de temporización, por ejemplo, al probar el hash de una contraseña creada vía la función crypt() (suponiendo que no pueda usar las funciones password_hash() y password_verify(), que no son sensibles a los ataques de temporización).
<?php
$expected = crypt('12345', '$2a$07$usesomesillystringforsalt$');
$correct = crypt('12345', '$2a$07$usesomesillystringforsalt$');
$incorrect = crypt('1234', '$2a$07$usesomesillystringforsalt$');
var_dump(hash_equals($expected, $correct));
var_dump(hash_equals($expected, $incorrect));
?>El ejemplo anterior mostrará:
bool(true) bool(false)
__debugInfo()Se ha añadido el método mágico __debugInfo() para permitir a los objetos cambiar las propiedades y valores que se muestran cuando el objeto se muestra usando la función 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 ejemplo anterior mostrará:
object(C)#1 (1) {
["propSquared"]=>
int(1764)
}
Se ha añadido el algoritmo de hashing gost-crypto.
Implementa la función de hashing GOST, usando las tablas CryptoPro S-box
como se especifica en la
» RFC 4357, sección 11.2.
Se han realizado diversas mejoras en el soporte SSL/TLS en PHP 5.6. Esto incluye la activación de forma predeterminada de la verificación de pares, el soporte para la coincidencia de huellas digitales de certificados, la mitigación de ataques de renegociación TLS, así como varias nuevas opciones de contexto SSL que permiten un control mucho más granular sobre la configuración del protocolo y la verificación al usar flujos cifrados.
Estos cambios se describen en detalle en la sección sobre los cambios OpenSSL en PHP 5.6.x de la guía de migración.
La extensión pgsql ahora soporta conexiones
y consultas asíncronas, habilitando un comportamiento no bloqueante al
interactuar con una base de datos PostgreSQL. Las conexiones asíncronas
pueden establecerse vía la constante PGSQL_CONNECT_ASYNC,
y las nuevas funciones pg_connect_poll(),
pg_socket(), pg_consume_input() y
pg_flush() pueden ser usadas para manejar las conexiones
y consultas asíncronas.