PHP 5.4.31 Released

New features

Expressions de constante scalaire

Il est désormais possible de fournir une expression scalaire impliquant des numériques et des chaînes lité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 
{
    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

Fonctions variables via l'opérateur ...

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

Décompression des arguments via l'opérateur ...

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 = [23];
echo 
add(1, ...$operators);
?>

L'exemple ci-dessus va afficher :

6

L'exponentiation via l'opérateur **

Un opérateur ** associatif à droite a été ajouté au support de l'exponentiation, en conjonction de l'opérateur d'assignement **=.

<?php
printf
("2 ** 3 ==      %d\n"** 3);
printf("2 ** 3 ** 2 == %d\n"** ** 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

use function et use const

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

phpdbg

PHP inclut désormais un dégogeur intéractif appelé phpdbg, implémenté comme module SAPI. Pour plus d'informations, visitez la » documentation phpdbg.

Encodage de caractères par défaut

default_charset est maintenant utilisé comme jeu de caractères par défaut pour les fonctions qui sont spécifiques pour l'encodage, comme htmlspecialchars(). Notez que si (maintenant obsolète) les configurations d'encodage d'iconv et mbstring sont définies, elles prendront le dessus par rapport à la configuration de default_charset.

La valeur par défaut pour cette configuration est UTF-8.

php://input est ré-utilisable

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.

Téléchargement de gros fichiers

Les fichiers de plus de 2 GigaOctets sont maintenant acceptés.

Surcharge d'opérateur avec le support GMP

Les objets GMP supporte 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);

// Code avant 5.6 :
var_dump(gmp_add($a$b));
var_dump(gmp_add($a17));
var_dump(gmp_add(42$b));

// Nouveau code :
var_dump($a $b);
var_dump($a 17);
var_dump(42 $b);
?>

hash_equals() pour la comparaison des chaînes permettant d'éviter les attaques de type timing

La fonction hash_equals() a été ajoutée pour comparer deux chaînes en temps constant. Ceci peut être utilisé pour éviter les attaques de type timing, pour l'instant, 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)

Algorithme de hashage gost-crypto

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.

Améliorations SSL/TLS

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 une 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.

Support async pgsql

L'extension pgsql supporte désormais les connexions et les requêtes, en activant un comportement non-bloquant lors de l'interaction avec la 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és pour gérer les connexions et les requêtes asynchrones.

add a note add a note

User Contributed Notes 4 notes

up
84
tr0y
6 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
2
Anonymous
12 days ago
Remember, that

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

Thats why exponent operator** is RIGHT associative.
up
16
ashnazg at php dot net
3 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
4
gmblar+php at gmail dot com
5 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