Edit Report a Bug

    Nouvelles fonctionnalités

    Expressions de constante

    Il est désormais possible de fournir une expression scalaire impliquant des numériques et des chaîne de caractères 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 les arguments par défaut de fonction.

    <?php
    const UN = 1;
    const     DEUX = UN * 2;

    class     C {
    const     TROIS = DEUX + 1;
    const     UN_TIERS = 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 tableau en utilisant le mot clé const :

    <?php
    const ARR = ['a', 'b'];

    echo     ARR[0];
    ?>

    L'exemple ci-dessus va afficher :

    a

    Fonctions variables via l'opérateur de décomposition ...

    Les fonctions variables peuvent maintenant être implémentées en utilisant l'opérateur de décomposition ..., 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 de décomposition ...

    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 de décomposition .... Cette méthode est connue sous le nom d'opérateur astérisque 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

    L'exponentiation via l'opérateur **

    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

    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 réalisé en utilisant les constructions use function et use const, respectivement.

    <?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ébogueur interactif 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 désormais 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 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.

    GMP supporte la surcharge d'opérateur

    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

    hash_equals() pour la comparaison des chaîne de caractères permettant d'éviter les attaques de type timing

    La fonction hash_equals() a été ajoutée pour comparer deux chaîne de caractères 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)

    __debugInfo()

    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)
}

    Algorithme de hachage gost-crypto

    L'algorithme de hachage gost-crypto a été ajouté. Il implémente la fonction de hachage 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 ont é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 chiffré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 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.

    add a note add a note

    User Contributed Notes 7 notes

    up
    164
    tr0y
    10 years 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
    36
    Anonymous
    10 years ago
    Remember, that

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

    Thats why exponent operator** is RIGHT associative.
    up
    40
    ashnazg at php dot net
    10 years 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
    7
    ciachn
    10 years ago
    Having 2 ** 3 ** 2 = 512 is actually that is the exact correct behavior for a right-associative operator just as specified in the "**" documentation.
    up
    12
    gmblar+php at gmail dot com
    10 years 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"
    up
    -1
    stocki dot r at gmail dot com
    3 years ago
    You can create a self-documented, named argument workaround in PHP 5.6-7 with ... operator:

    <?php
    htmlspecialchars    ($string, ...array_values([
            'flags'         => ENT_COMPAT | ENT_HTML401,
            'encoding'      => 'UTF-8',
            'double_encode' => false,
    ]))
    ?>
    up
    -7
    BernieV
    4 years ago
    The splat operator (...) is documented everywhere with no space after it.
    But it seems to work just as well with whitespace between ... and what follows.
    My IDE line-wrapped, introducing white-space, immediately after the ...
    add a note add a note
    To Top