Ahora es posible proporcionar una expresión escalar que implique números y literales de string y/o constantes en contextos donde PHP previamente esperaba un valor estático, como una constante o una declaración de propiedades y los argumentos por defecto de función.
<?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 resultado del ejemplo sería:
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 resultado del ejemplo sería:
a
...
Las funciones variables
ahora pueden ser implementadas 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 resultado del ejemplo sería:
$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 pueden ser descomprimidos
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, por ejemplo.
<?php
function add($a, $b, $c) {
return $a + $b + $c;
}
$operators = [2, 3];
echo add(1, ...$operators);
?>El resultado del ejemplo sería:
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 resultado del ejemplo sería:
2 ** 3 == 8 2 ** 3 ** 2 == 512 a == 8
use function y use const
El operador
use
ha sido extendido para soportar la importación de funciones y constantes
además de clases. Esto se realiza 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 resultado del ejemplo sería:
42 Name\Space\f
PHP ahora incluye un depurador interactivo llamado phpdbg, implementado como un módulo SAPI. Para más información, visite la documentación phpdbg.
default_charset ahora se usa como el conjunto de caracteres por defecto para las funciones htmlentities(), html_entity_decode() y htmlspecialchars(). Tenga 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 por defecto para esta configuración es UTF-8.
php://input es reutilizable
php://input
ahora puede ser reabierto y leído 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 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 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 resultado del ejemplo sería:
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 resultado del ejemplo sería:
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 ha realizado una amplia gama de mejoras en el soporte SSL/TLS en PHP 5.6. Esto incluye la activación de la verificación por pares por defecto, soportando la coincidencia de certificados de huellas digitales, permitiendo limitar los ataques de renegociación TLS, así como varias nuevas opciones de contexto SSL permitiendo un control más fino del protocolo y las verificaciones de configuración cuando se usan 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.