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

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

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

 <sect2 xml:id="migration70.new-features.scalar-type-declarations">
  <title>Déclarations du type scalaire</title>

  <para>
   Les <link linkend="language.types.declarations">déclarations de type</link>
   scalaire viennent en deux modes : coercitive (par défaut) ou stricte. Les types de paramètres
   suivants peuvent être renforcés (soit coercitif soit strict) : les chaînes de caractères
   (<type>string</type>), les entiers (<literal>int</literal>),
   les décimaux (<type>float</type>) et les valeurs booléennes (<literal>bool</literal>).
   Ils complémentent les autres types introduits dans PHP 5 : les noms des classes, les interfaces,
   les tableaux (<type>array</type>) et les fonctions appelables (<type>callable</type>).
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
// Mode coercitive
function sommeEntiers(int ...$entiers)
{
    return array_sum($entiers);
}

var_dump(sommeEntiers(2, '3', 4.1));
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
int(9)
]]>
   </screen>
  </informalexample>

  <para>
   Pour activer le mode strict, une seule directive &declare; doit être placée
   en haut du fichier. Ceci signifie que le mode strict de déclaration du type
   scalaire est configurée par fichier. La directive n'affecte pas seulement la
   déclaration des paramètres mais aussi le type de retour de la fonction (voir
   <link linkend="language.types.declarations">les déclarations du type de retour</link>
   dans les fonctions PHP et celles issues des extensions).
  </para>

  <para>
   Une documentation complète et des exemples de déclarations du type scalaire
   peuvent être trouvés dans la référence : <link linkend="language.types.declarations">Déclarations de type</link>.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.return-type-declarations">
  <title>Déclarations du type de retour</title>

  <para>
   PHP 7 ajoute un support pour  les
   <link linkend="language.types.declarations">déclarations du type de retour</link>.
   Similaires aux 
   <link linkend="language.types.declarations">déclarations du type d'argument</link>,
   les déclarations du type de retour spécifient le type de la valeur qui sera retournée par la fonction.
   Les mêmes 
   <link linkend="language.types.declarations">types</link>
   qui sont disponibles pour les déclarations du type de retour sont disponibles pour les déclarations
   du type d'argument.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

function sommeTableaux(array ...$tableaux): array
{
    return array_map(function(array $tableaux): int {
        return array_sum($tableaux);
    }, $tableaux);
}

print_r(sommeTableaux([1,2,3], [4,5,6], [7,8,9]));
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
Array
(
    [0] => 6
    [1] => 15
    [2] => 24
)
]]>
   </screen>
  </informalexample>

  <para>
   Une documentation complète et des exemples de déclarations du type de retour
   peuvent être trouvés dans la référence : <link linkend="language.types.declarations">Déclarations du type de retour</link>.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.null-coalesce-op">
  <title>L'opérateur Null coalescent</title>

  <para>
   L'opérateur Null coalescent (<literal>??</literal>) a été ajouté comme un sucre 
   syntaxique pour les cas de besoin les plus communs d'utiliser une troisième conjonction 
   avec la fonction <function>isset</function>. Il retourne le premier opérande s'il existe 
   et n'a pas une valeur &null;; et retourne le second opérande sinon.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
// Récupére la valeur de $_GET['utilisateur'] retourne 'aucun'
// s'il n'existe pas.
$identifiant = $_GET['utilisateur'] ?? 'aucun';
// Ceci est équivalent à :
$identifiant = isset($_GET['utilisateur']) ? $_GET['utilisateur'] : 'aucun';

// L'opérateur permet de faire du chaînage : Ceci va retourner la première
// valeur définie respectivement dans $_GET['utilisateur'], $_POST['utilisateur']
// et 'aucun'.
$identifiant = $_GET['utilisateur'] ?? $_POST['utilisateur'] ?? 'aucun';
?>
]]>
   </programlisting>
  </informalexample>

  <!-- TODO: we don't need further details here, but this still has to be
       added to the operator precedence table -->
 </sect2>

 <sect2 xml:id="migration70.new-features.spaceship-op">
  <title>L'opérateur Spaceship</title>
  <para>
   L'opérateur Spaceship est utilisé pour comparer deux expressions. 
   Il retourne -1, 0 ou 1 quand <varname>$a</varname> est respectivement inférieur, 
   égal ou supérieur à <varname>$b</varname>. Les comparaisons sont effectuées 
   selon 
   <link linkend="types.comparisons">les règles de comparaison de types</link> 
   habituelles de PHP.
  </para>
  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
// Entiers
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

// Nombres à virgule flottante
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
 
// Chaînes de caractères
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
?>
]]>
   </programlisting>
  </informalexample>

  <!-- TODO: we don't need further details here, but this still has to be
       added to the operator precedence table -->
 </sect2>

 <sect2 xml:id="migration70.new-features.define-array">
  <title>Les tableaux constants à l'aide de <function>define</function></title>

  <para>
   Les tableaux (<type>Array</type>) constants peuvent maintenant être définis 
   avec la fonction <function>define</function>. Dans PHP 5.6, ils pouvaient 
   être définis seulement avec &const;.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
define('ANIMAUX', [
    'chien',
    'chat',
    'oiseau'
]);

echo ANIMAUX[1]; // affiche "chat"
?>
]]>
   </programlisting>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.anonymous-classes">
  <title>Les classes anonymes</title>

  <para>
   La prise en charge des classes anonymes a été ajoutée à travers 
   l'instanciation <literal>new class</literal>. Celle-ci peut être utilisée 
   au lieu de définir toute une classe pour des objets jetables :
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
interface Logger {
    public function log(string $msg);
}

class Application {
    private $logger;

    public function getLogger(): Logger {
         return $this->logger;
    }

    public function setLogger(Logger $logger) {
         $this->logger = $logger;
    }
}

$app = new Application;
$app->setLogger(new class implements Logger {
    public function log(string $msg) {
        echo $msg;
    }
});

var_dump($app->getLogger());
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
object(class@anonymous)#2 (0) {
}
]]>
   </screen>
  </informalexample>

  <para>
   La documentation complète peut être trouvée dans 
   <link linkend="language.oop5.anonymous">la référence des classes anonymes</link>.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.unicode-codepoint-escape-syntax">
  <title>Syntaxe d’échappement du point de code Unicode</title>

  <para>
   Cela prend un point de code Unicode sous forme hexadécimale, dans une chaîne 
   entre doubles guillemets ou une syntaxe heredoc, pour le convertir 
   en UTF-8. N’importe quel point de code valide est accepté, 
   les zéros en début de chaîne étant facultatifs.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
echo "\u{aa}";
echo "\u{0000aa}";
echo "\u{9999}";
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
ª
ª (même affichage que la ligne précédente mais avec des zéros en début de chaîne)
香
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.closure-call-method">
  <title><methodname>Closure::call</methodname></title>

  <para>
   La méthode <methodname>Closure::call</methodname> est devenue plus performante. 
   Une façon plus courte de lier temporairement une fermeture à la portée d'un 
   objet et l'invoquer.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
class A {private $x = 1;}

// Code avant PHP 7
$getX = function() {return $this->x;};
$getXCB = $getX->bindTo(new A, 'A'); // fermeture intermédiaire
echo $getXCB();

// Code PHP 7+
$getX = function() {return $this->x;};
echo $getX->call(new A);
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
1
1
]]>
   </screen>
  </informalexample>
 </sect2>
 <sect2 xml:id="migration70.new-features.filtered-unserialize">
  <title><function>unserialize</function> est filtrée</title>

  <para>
   Cette fonctionnalité vise à garantir une meilleure sécurité lorsque 
   la désérialisation d’objets est effectuée avec des données non fiables. 
   Elle empêche les injections de code possible en permettant au développeur 
   de whitelister les classes qui peuvent être désérialisées.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

// Convertit tous les objets vers un objet __PHP_Incomplete_Class
$data = unserialize($foo, ["allowed_classes" => false]);

// Convertit tous les objets vers un objet __PHP_Incomplete_Class 
// exceptés ceux de MyClass et MyClass2
$data = unserialize($foo, ["allowed_classes" => ["MyClass", "MyClass2"]]);

// Comportement par défaut (le même que lorsqu'on omet le deuxième argument) 
// qui accepte toutes les classes
$data = unserialize($foo, ["allowed_classes" => true]);
]]>
   </programlisting>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.intlchar">
  <title><classname>IntlChar</classname></title>

  <para>
   La nouvelle classe <classname>IntlChar</classname> cherche à exposer 
   la fonctionnalité ICU en plus. La classe elle-même définit un nombre de méthodes 
   statiques et de constantes qui peuvent être utilisées pour manipuler les 
   caractères unicode.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

printf('%x', IntlChar::CODEPOINT_MAX);
echo IntlChar::charName('@');
var_dump(IntlChar::ispunct('!'));
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
10ffff
COMMERCIAL AT
bool(true)
]]>
   </screen>
  </informalexample>

  <para>
   Pour utiliser cette classe, vous devez installer l'extension 
   <link linkend="book.intl">Intl</link>.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.expectations">
  <title>Les attentes</title>

  <para>
   <link linkend="function.assert.expectations">Les attentes</link> sont 
   une amélioration rétro-compatible apportée à l'ancienne fonction
   <function>assert</function>. Ils offrent des assertions à très faible
   coût dans le code de production et permettent de lever des exceptions 
   personnalisées lorsque l’assertion échoue.
  </para>

  <para>
   Alors que l'ancienne API continue à être maintenue pour des raisons de
   compatibilité, la fonction <function>assert</function> est maintenant 
   une construction de language, permettant au premier paramètre d'être 
   une expression plutôt qu'un <type>string</type> à évaluer ou un 
   <type>bool</type> à tester.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
ini_set('assert.exception', 1);

class CustomError extends AssertionError {}

assert(false, new CustomError('Un message d\'erreur'));
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
Fatal error: Uncaught CustomError: Un message d\'erreur
]]>
   </screen>
  </informalexample>

  <para>
   On trouvera plus de détails sur cette fonctionnalité, y compris la façon de la configurer
   dans les environnements de développement et de production, dans 
   <link linkend="function.assert.expectations">la section attentes</link> 
   dans la référence de la fonction <function>assert</function>.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.group-use-declarations">
  <title>Grouper les déclarations <literal>use</literal></title>

  <para>
   Les classes, les fonctions et les constantes importées à partir du même &namespace;
   peuvent être groupées maintenant dans une seule instruction &use.namespace;.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
// Code avant PHP 7
use some\namespace\ClassA;
use some\namespace\ClassB;
use some\namespace\ClassC as C;

use function some\namespace\fn_a;
use function some\namespace\fn_b;
use function some\namespace\fn_c;

use const some\namespace\ConstA;
use const some\namespace\ConstB;
use const some\namespace\ConstC;

// Code PHP 7+
use some\namespace\{ClassA, ClassB, ClassC as C};
use function some\namespace\{fn_a, fn_b, fn_c};
use const some\namespace\{ConstA, ConstB, ConstC};
?>
]]>
   </programlisting>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.generator-return-expressions">
  <title>Expressions de retour générateur</title>

  <para>
   Cette fonction se base sur la fonctionnalité de générateur introduite dans PHP 5.5. 
   Elle permet d'utiliser une instruction <literal>return</literal> dans un générateur 
   pour retourner une expression finale (le retour par référence n'est pas autorisé). 
   Cette valeur peut être extraite en utilisant la nouvelle méthode  
   <literal>Generator::getReturn()</literal>, qui ne peut être utilisée que lorsque 
   le générateur a fini de rendre les valeurs.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

$gen = (function() {
    yield 1;
    yield 2;

    return 3;
})();

foreach ($gen as $val) {
    echo $val, PHP_EOL;
}

echo $gen->getReturn(), PHP_EOL;
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
1
2
3
]]>
   </screen>
  </informalexample>

  <para>
   C'est très pratique d'être capable de renvoyer explicitement une valeur finale 
   d'un générateur. Car cela permet à une valeur finale, susceptible d'être gérée 
   spécialement par le code client exécutant le générateur, d'être retournée par le générateur 
   (peut-être à partir d'une forme de calcul coroutine). C'est de loin plus simple 
   que de forcer le code client à vérifier d'abord si la valeur finale a été rendue,
   puis de gérer spécifiquement la valeur quand c'est le cas.
  </para>
 </sect2>
 <sect2 xml:id="migration70.new-features.generator-delegation">
  <title>Délégation de générateur</title>

  <para>
   Les générateurs peuvent maintenant être délégués automatiquement à un autre générateur, 
   un objet <classname>Traversable</classname> ou un <type>array</type>, 
   en utilisant &yield.from;, sans avoir recours à un boilerplate.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
function gen()
{
    yield 1;
    yield 2;
    yield from gen2();
}

function gen2()
{
    yield 3;
    yield 4;
}

foreach (gen() as $val)
{
    echo $val, PHP_EOL;
}
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
1
2
3
4
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.intdiv">
  <title>La division d’entiers avec <function>intdiv</function></title>

  <para>
   La nouvelle fonction <function>intdiv</function> retourne le résultat de la division 
   d'entiers effectuée sur ses opérandes.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
var_dump(intdiv(10, 3));
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
int(3)
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.session-options">
  <title>Les options de session</title>

  <para>
   La fonction <function>session_start</function> accepte maintenant un <type>array</type> 
   d'options qui surcharge 
   <link linkend="session.configuration">les directives de configuration de session</link> 
   manuellement configurées dans le fichier php.ini.
  </para>

  <para>
   Ces options ont aussi étendu le support pour l'option
   <link linkend="ini.session.lazy-write">session.lazy_write</link>, 
   qui est activée par défaut et pousse PHP à surcharger les fichiers de session 
   seulement si les données de session ont été mises à jour, et l'option 
   <literal>read_and_close</literal>, ne pouvant être passée à la fonction 
   <function>session_start</function> que pour indiquer si les données de session 
   doivent être lues avant que la session soit terminée sans changements.
  </para>

  <para>
   Par exemple, pour mettre <link linkend="ini.session.cache-limiter">session.cache_limiter</link> 
   à <literal>private</literal> et fermer immédiatement la session après l'avoir lue :
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
session_start([
    'cache_limiter' => 'private',
    'read_and_close' => true,
]);
?>
]]>
   </programlisting>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.preg-repace-callback-array-function">
  <title><function>preg_replace_callback_array</function></title>

  <para>
   La nouvelle fonction <function>preg_replace_callback_array</function> 
   permet au code d'être écrit de façon plus propre en utilisant la fonction 
   <function>preg_replace_callback</function>. Avant PHP 7, les fonctions de rappel (callback) 
   devaient être exécutées par expression régulière ce qui demande à la fonction de rappel 
   d'être salie avec beaucoup de ramifications.
  </para>

  <para>
   Maintenant, les fonctions de rappel peuvent être enregistrées pour chaque expression 
   régulière en utilisant un tableau associatif, là où la clé est une expression régulière 
   ayant la fonction de rappel comme valeur.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.csprng-functions">
  <title>Les fonctions <link linkend="book.csprng">CSPRNG</link></title>

  <para>
   Deux nouvelles fonctions ont été ajoutées pour générer cryptographiquement des entiers 
   et des chaînes de caractères sécurisées de façon multi-plateforme :
   <function>random_bytes</function> et <function>random_int</function>.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.list-arrayaccess">
  <title>
   La fonction <function>list</function> peut toujours déballer les objets qui implémentent
   <classname>ArrayAccess</classname>
  </title>

  <para>
   Auparavant, la fonction <function>list</function> ne pouvait pas opérer à 100% sur des objets 
   qui implémentent <classname>ArrayAccess</classname>. Maintenant, ça a été corrigé.
  </para>
 </sect2>
 
 <sect2 xml:id="migration70.new-features.others">
  <title>Autres fonctionnalités</title>
  <itemizedlist>
   <listitem>
    <simpara>
     L'accès aux membres de la classe (attributs et méthodes) lors du clonage a été ajouté.
     Exemple, <literal>(clone $foo)-&gt;bar()</literal>.
    </simpara>
   </listitem>
  </itemizedlist>
 </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
-->