Il est désormais possible de fournir une expression scalaire impliquant des numériques et des chaînes littérales et/ou des constantes dans les contextes où PHP attendait précédemment une valeur statique, comme une constante ou une déclaration de propriétés et des arguments par défaut de fonction.
<?php
const UN = 1;
const DEUX = UN * 2;
class C {
const TROIS = DEUX + 1;
const UN_SUR_TROIS = UN / self::TROIS;
const RESULTAT = 'La valeur de TROIS est '.self::TROIS;
public function f($a = UN + self::TROIS) {
return $a;
}
}
echo (new C)->f()."\n";
echo C::RESULTAT;
?>
L'exemple ci-dessus va afficher :
4 La valeur de TROIS est 3
Il est aussi possible de définir une constante array en utilisant le mot clé const :
<?php
const ARR = ['a', 'b'];
echo ARR[0];
?>
L'exemple ci-dessus va afficher :
a
Les fonctions variables peuvent maintenant être implémentées en utilisant l'opérateur ..., au lieu d'utiliser la fonction func_get_args().
<?php
function f($req, $opt = null, ...$params) {
// $params est un tableau contenant les arguments restants.
printf('$req: %d; $opt: %d; Nombre d\'arguments : %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);
?>
L'exemple ci-dessus va afficher :
$req: 1; $opt: 0; Nombre d'arguments : 0 $req: 1; $opt: 2; Nombre d'arguments : 0 $req: 1; $opt: 2; Nombre d'arguments : 1 $req: 1; $opt: 2; Nombre d'arguments : 2 $req: 1; $opt: 2; Nombre d'arguments : 3
Les tableaux et les objets Traversable peuvent être décompressés dans la liste d'arguments lors d'appel à une fonction en utilisant l'opérateur .... Cette méthode est connue sous le nom d'opérateur de floc dans d'autres langages comme Ruby par exemple.
<?php
function add($a, $b, $c) {
return $a + $b + $c;
}
$operators = [2, 3];
echo add(1, ...$operators);
?>
L'exemple ci-dessus va afficher :
6
Un opérateur ** associatif à droite a été ajouté pour supporter l'exponentiation, en conjonction de l'opérateur d'assignement **=.
<?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);
?>
L'exemple ci-dessus va afficher :
2 ** 3 == 8 2 ** 3 ** 2 == 512 a == 8
L'opérateur use a été étendu pour supporter l'importation de fonctions et de constantes en plus des classes. Ceci est possible en utilisant respectivement les constructions use function et use const.
<?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();
}
?>
L'exemple ci-dessus va afficher :
42 Name\Space\f
PHP inclut désormais un débogueur interactif appelé phpdbg, implémenté comme module SAPI. Pour plus d'informations, visitez la » documentation phpdbg.
default_charset est maintenant utilisé comme jeu de caractères par défaut pour les fonctions htmlentities(), html_entity_decode() et htmlspecialchars(). Notez que si les configurations d'encodage (maintenant obsolète) d'iconv et mbstring sont définies, elles prendront le dessus par rapport à la configuration de default_charset pour les fonctions iconv et mbstring, respectivement.
La valeur par défaut pour cette configuration est UTF-8.
php://input peut maintenant être ré-ouvert et lu autant de fois que nécessaire. Ce nouveau mécanisme a permis également de réduire significativement la quantité de mémoire requise lors des opérations POST.
Les fichiers de plus de 2 GigaOctets sont maintenant acceptés.
Les objets GMP supportent maintenant la surcharge des opérateurs et le transtypage en types scalaires. Ceci permet un code plus expressif en utilisant 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;
}
?>
L'exemple ci-dessus va afficher :
59 59 59
La fonction hash_equals() a été ajoutée pour comparer deux chaînes en temps constant. Ceci devrait être utilisé pour éviter les attaques de type timing, par exemple, lors d'un test du hash d'un mot de passe créé via la fonction crypt() (en supposant que vous ne pouvez pas utiliser les fonctions password_hash() et password_verify(), qui ne sont pas sensibles aux attaques de type timing).
<?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));
?>
L'exemple ci-dessus va afficher :
bool(true) bool(false)
La méthode magique __debugInfo() a été ajoutée pour permettre aux objets de changer les propriétés et les valeurs qui sont affichées lorsque l'objet est affiché en utilisant la fonction 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));
?>
L'exemple ci-dessus va afficher :
object(C)#1 (1) {
["propSquared"]=>
int(1764)
}
L'algorithme de hashage gost-crypto a été ajouté. Il implémente la fonction de hashage GOST, en utilisant les tables CryptoPro S-box tel que spécifié par la » RFC 4357, section 11.2.
Un large éventail d'améliorations a été réalisé sur le support SSL/TLS en PHP 5.6. Ceci inclut l'activation de la vérification par paire par défaut, supportant la correspondance des certificats d'empreintes, permettant de limiter les attaques à la renégociation TLS, ainsi que plusieurs nouvelles options de contexte SSL permettant un contrôle plus fin du protocole et des vérifications des configurations lors de l'utilisation des flux cryptés.
Ces modifications sont décrites en détail dans la section sur les changements OpenSSL en PHP 5.6.x du guide de migration.
L'extension pgsql supporte désormais les
connexions et les requêtes asynchrones, en activant un comportement non-bloquant
lors de l'interaction avec une base de données PostgreSQL. Les
connexions asynchrones peuvent être établies via la constante
PGSQL_CONNECT_ASYNC, et les nouvelles fonctions
pg_connect_poll(), pg_socket(),
pg_consume_input() et pg_flush()
peuvent être utilisées pour gérer les connexions et les requêtes asynchrones.