doc-fr/appendices/migration56/new-features.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<!-- EN-Revision: c9b1de1c1266145d5472d0c05edea2c1bf970ff0 Maintainer: yannick Status: ready -->
<!-- Reviewed: yes Maintainer: girgias -->

<sect1 xml:id="migration56.new-features" xmlns:xlink="http://www.w3.org/1999/xlink">
 <title>Nouvelles fonctionnalités</title>

 <sect2 xml:id="migration56.new-features.const-scalar-exprs">
  <title>Expressions de constante</title>

  <para>
   Il est désormais possible de fournir une expression scalaire impliquant
   des numériques et des &string; 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.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?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;
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
4
La valeur de TROIS est 3
]]>
   </screen>
  </informalexample>

 <para>
   Il est aussi possible de définir une constante &array; en
   utilisant le mot clé <literal>const</literal> :
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
const ARR = ['a', 'b'];

echo ARR[0];
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
a
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration56.new-features.variadics">
  <title>Fonctions variables via l'opérateur de décomposition <literal>...</literal></title>

  <para>
   Les <link linkend="functions.variable-arg-list">fonctions variables</link>
   peuvent maintenant être implémentées en utilisant l'opérateur de décomposition <literal>...</literal>,
   au lieu d'utiliser la fonction <function>func_get_args</function>.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?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);
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
$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
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration56.new-features.splat">
  <title>Décompression des arguments via l'opérateur de décomposition <literal>...</literal></title>

  <para>
   Les <link linkend="language.types.array">Tableaux</link> et les objets
   <interfacename>Traversable</interfacename> peuvent être décompressés
   dans la liste d'arguments lors d'appel à une fonction en utilisant
   l'opérateur de décomposition <literal>...</literal>. Cette méthode est connue sous
   le nom d'opérateur astérisque dans d'autres langages comme Ruby par exemple.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
function add($a, $b, $c) {
    return $a + $b + $c;
}

$operators = [2, 3];
echo add(1, ...$operators);
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
6
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration56.new-features.exponentiation">
  <title>L'exponentiation via l'opérateur <literal>**</literal></title>

  <para>
   Un opérateur <literal>**</literal> associatif à droite a été ajouté
   pour supporter l'exponentiation, en conjonction de l'opérateur
   d'assignement <literal>**=</literal>.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?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);
?>
]]>
   </programlisting>
  &example.outputs;
  <screen>
<![CDATA[
2 ** 3 ==      8
2 ** 3 ** 2 == 512
a ==           8
]]>
  </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration56.new-features.use">
  <title><literal>use function</literal> et <literal>use const</literal></title>

  <para>
   L'opérateur
   <link linkend="language.namespaces.importing"><literal>use</literal></link>
   a été étendu pour supporter l'importation de fonctions et de constantes
   en plus des classes. Ceci est réalisé en utilisant les constructions
   <literal>use function</literal> et <literal>use const</literal>, respectivement.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?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();
}
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
42
Name\Space\f
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration56.new-features.phpdbg">
  <title>phpdbg</title>

  <para>
   PHP inclut désormais un débogueur interactif appelé phpdbg, implémenté
   comme module SAPI. Pour plus d'informations, visitez la
   <link linkend="book.phpdbg">documentation phpdbg</link>.
  </para>
 </sect2>

 <sect2 xml:id="migration56.new-features.default-encoding">
  <title>Encodage de caractères par défaut</title>

  <para>
   <link linkend="ini.default-charset">default_charset</link> est désormais
   utilisé comme jeu de caractères par défaut pour les fonctions
   <function>htmlentities</function>, <function>html_entity_decode</function> et
   <function>htmlspecialchars</function>.
   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.
  </para>

  <para>
   La valeur par défaut pour cette configuration est <literal>UTF-8</literal>.
  </para>
 </sect2>

 <sect2 xml:id="migration56.new-features.reusable-input">
  <title><link linkend="wrappers.php.input"><literal>php://input</literal></link> est ré-utilisable</title>

  <para>
   <link linkend="wrappers.php.input"><literal>php://input</literal></link>
   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.
  </para>
 </sect2>

 <sect2 xml:id="migration56.new-features.large-file">
  <title>Téléchargement de gros fichiers</title>

  <para>
   Les fichiers de plus de 2 GigaOctets sont maintenant acceptés.
  </para>
 </sect2>

 <sect2 xml:id="migration56.new-features.gmp">
  <title><link linkend="book.gmp">GMP</link> supporte la surcharge d'opérateur</title>
  <para>
   Les objets <link linkend="book.gmp">GMP</link> supportent maintenant la surcharge
   des opérateurs et le transtypage en types scalaires. Ceci permet un code plus
   expressif en utilisant GMP :
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?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;
}
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
59
59
59
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration56.new-features.hash-equals">
  <title><function>hash_equals</function> pour la comparaison des &string; permettant d'éviter les attaques de type timing</title>

  <para>
   La fonction <function>hash_equals</function> a été ajoutée pour comparer deux
   &string; 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 <function>crypt</function> (en supposant que vous ne
   pouvez pas utiliser les fonctions <function>password_hash</function> et
   <function>password_verify</function>, qui ne sont pas sensibles aux attaques de type timing).
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?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));
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
bool(true)
bool(false)
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration56.new-features.debuginfo">
  <title><literal>__debugInfo()</literal></title>

  <para>
   La méthode magique <link linkend="language.oop5.magic.debuginfo">__debugInfo()</link>
   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
   <function>var_dump</function>.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?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));
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
object(C)#1 (1) {
  ["propSquared"]=>
  int(1764)
}
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration56.new-features.gost">
  <title>Algorithme de hachage gost-crypto</title>

  <para>
   L'algorithme de hachage <literal>gost-crypto</literal> a été ajouté.
   Il implémente la fonction de hachage GOST, en utilisant les tables
   CryptoPro S-box tel que spécifié par la
   <link xlink:href="&url.rfc;4357">RFC 4357, section 11.2</link>.
  </para>
 </sect2>

 <sect2 xml:id="migration56.new-features.openssl">
  <title>Améliorations SSL/TLS</title>

  <para>
   Un large éventail d'améliorations ont été réalisé sur le support SSL/TLS en
   PHP 5.6. Ceci inclut
   <link linkend="migration56.incompatible.peer-verification">l'activation de
    la vérification par paire par défaut</link>, supportant la correspondance
   des certificats d'empreintes, permettant de limiter les attaques à la
   renégociation TLS, ainsi que plusieurs nouvelles
   <link linkend="context.ssl">options de contexte SSL</link> permettant
   un contrôle plus fin du protocole et des vérifications des configurations
   lors de l'utilisation des flux chiffrés.
  </para>

  <para>
   Ces modifications sont décrites en détail dans la section sur
   les <link linkend="migration56.openssl">changements OpenSSL en PHP 5.6.x</link>
   du guide de migration.
  </para>
 </sect2>

 <sect2 xml:id="migration56.new-features.postgresql">
  <title>Support async <link linkend="book.pgsql">pgsql</link></title>

  <para>
   L'extension <link linkend="book.pgsql">pgsql</link> 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
   <constant>PGSQL_CONNECT_ASYNC</constant>, et les nouvelles fonctions
   <function>pg_connect_poll</function>, <function>pg_socket</function>,
   <function>pg_consume_input</function> et <function>pg_flush</function>
   peuvent être utilisées pour gérer les connexions et les requêtes asynchrones.
  </para>
 </sect2>
</sect1>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->