doc-fr/language/types/type-juggling.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: e2f53f0f601cd3e97ebdb516e51de1825d0106ea Maintainer: girgias Status: ready -->
<!-- Reviewed: no -->
<sect1 xml:id="language.types.type-juggling">
 <title>Jonglage de type</title>

 <simpara>
  PHP ne requis pas une définition de type explicite dans les déclarations de variables.
  Dans ce cas, le type d'une variable est déterminé en fonction de la valeur qu'elle a stocké.
  C'est-à-dire, si une <type>string</type> est assigné à la variable
  <varname>$var</varname>, alors <varname>$var</varname> est de type
  <type>string</type>. Si après une valeur <type>int</type> est assigné à
  <varname>$var</varname>, elle sera de type <type>int</type>.
 </simpara>

 <para>
  PHP peut tenter de convertir le type d'une valeur en une autre automatiquement
  dans certains contextes. Les différents contextes qui existent sont :
  <itemizedlist>
   <listitem>
    <simpara>Numérique</simpara>
   </listitem>
   <listitem>
    <simpara>String</simpara>
   </listitem>
   <listitem>
    <simpara>Logique</simpara>
   </listitem>
   <listitem>
    <simpara>Intégral et string</simpara>
   </listitem>
   <listitem>
    <simpara>Comparatif</simpara>
   </listitem>
   <listitem>
    <simpara>Fonction</simpara>
   </listitem>
  </itemizedlist>
 </para>

 <note>
  <simpara>
   Quand une valeur à besoin d'être interpréter comme un type différent,
   la valeur elle-même <emphasis>ne change pas</emphasis> de type.
  </simpara>
 </note>

 <simpara>
  Pour forcer une variable a être évaluer comme un type particulier, voir la
  section sur le <link linkend="language.types.typecasting">casting de type</link>.
  Pour changer le type d'une variable, voir la fonction <function>settype</function>.
 </simpara>

 <sect2>
  <title>Contextes numériques</title>

  <simpara>
   Ceci est le contexte lors de l'utilisation d'
   <link linkend="language.operators.arithmetic">opérateur arithmétique</link>.
  </simpara>

  <simpara>
   Dans ce contexte si un des opérandes est un <type>float</type> (ou pas
   interprétable comme <type>int</type>), les deux opérandes sont interprétés
   comme des <type>float</type>s, et le résultat sera un <type>float</type>.
   Sinon, les opérandes sont interprétés comme des <type>int</type>s,
   et le résultat sera aussi un <type>int</type>.
   À partir de PHP 8.0.0, si un des opérandes ne peut être interprétés une
   <classname>TypeError</classname> est lancée.
  </simpara>
 </sect2>

 <sect2>
  <title>Contextes string</title>

  <simpara>
   Ceci est le contexte lors de l'utilisation de <function>echo</function>,
   <function>print</function>, <link linkend="language.types.string.parsing">l'interpolation de chaînes de caractères</link>, ou l'
   <link linkend="language.operators.string">opérateur de concaténation</link>
   pour les chaînes de caractères.
  </simpara>

  <simpara>
   Dans ce contexte la valeur sera interprété comme une <type>string</type>.
  </simpara>
 </sect2>

 <sect2>
  <title>Contextes logiques</title>

  <simpara>
   Ceci est le contexte lors de l'utilisation de déclarations conditionnelles,
   l'<link linkend="language.operators.comparison.ternary">opérateur ternaire</link>,
   ou un <link linkend="language.operators.logical">opérateur logique</link>.
  </simpara>

  <simpara>
   Dans ce contexte la valeur sera interprété comme un <type>bool</type>.
  </simpara>
 </sect2>

 <sect2>
  <title>Contextes intégraux et string</title>

  <simpara>
   Ceci est le contexte lors de l'utilisation d'un
   <link linkend="language.operators.bitwise">opérateur bit à bit</link>.
  </simpara>

  <simpara>
   Dans ce contexte si tous les opérandes sont de type <type>string</type>
   alors le résultat sera aussi une <type>string</type>.
   Sinon, les opérandes seront interprétés comme des <type>int</type>s,
   et le résultat sera aussi un <type>int</type>.
   À partir de PHP 8.0.0, si un des opérandes ne peut être interprétés une
   <classname>TypeError</classname> est lancée.
  </simpara>
 </sect2>

 <sect2>
  <title>Contextes comparatifs</title>

  <simpara>
   Ceci est le contexte lors de l'utilisation d'un
   <link linkend="language.operators.comparison">opérateur de comparaison</link>.
  </simpara>

  <simpara>
   Les conversions de types qui se produisent dans ce contexte sont expliqués
   dans le <link linkend="language.operators.comparison.types">tableau</link>
   Comparaison avec plusieurs types.
  </simpara>
 </sect2>

 <sect2>
  <title>Contextes de fonctions</title>

  <simpara>
   Ceci est le contexte quand une valeur est passé à un paramètre ou propriété
   typé ou retourné depuis une fonction qui déclare un type de retour.
  </simpara>

  <para>
   Dans ce contexte, quand le mode de typage coercitif est actif (par défaut),
   seul les valeurs scalaires peuvent être convertie en une autre valeur scalaire.
   Pour les déclarations de types simples le comportement est le suivant :
   <itemizedlist>
    <listitem>
     <simpara>
      Type de déclaration <type>bool</type> : valeur est interprété comme <type>bool</type>.
     </simpara>
     <simpara>
      Type de déclaration <type>int</type> : valeur est interprété comme <type>int</type>
      si la conversion est bien-définie. C.-à-d. si la chaîne est
      <link linkend="language.types.numeric-strings">numeric</link>.
     </simpara>
     <simpara>
      Type de déclaration <type>float</type> : valeur est interprété comme <type>float</type>
      si la conversion est bien-définie. C.-à-d. si la chaîne est
      <link linkend="language.types.numeric-strings">numeric</link>.
     </simpara>
     <simpara>
      Type de déclaration <type>string</type> : valeur est interprété comme <type>string</type>.
     </simpara>
    </listitem>
   </itemizedlist>

   Si la déclaration de type est une union, voir la section à propos du
   <link linkend="language.types.declarations.union.coercive">Typage coercitif avec les types d'union</link>.
  </para>

  <warning>
   <simpara>
    <link linkend="functions.internal">Les fonctions internes</link> convertissent automatiquement &null; en type scalaire,
    ce comportement est <emphasis>OBSOLÈTE</emphasis> à partir de PHP 8.1.0.
   </simpara>
  </warning>
 </sect2>

 <sect2 xml:id="language.types.typecasting">
  <title>Cast de type</title>

  <simpara>
   Le casting de type convertie la valeur à un type donnée en écrivant le type
   entre parenthèse avant la valeur à convertir.
  </simpara>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
$foo = 10;   // $foo is an integer
$bar = (bool) $foo;   // $bar is a boolean
?>
]]>
   </programlisting>
  </informalexample>

  <simpara>
   Les casts permis sont :
  </simpara>

  <simplelist>
   <member><literal>(int)</literal> - cast en <type>int</type></member>
   <member><literal>(bool)</literal> - cast en <type>bool</type></member>
   <member><literal>(float)</literal> - cast en <type>float</type></member>
   <member><literal>(string)</literal> - cast en <type>string</type></member>
   <member><literal>(array)</literal> - cast en <type>array</type></member>
   <member><literal>(object)</literal> - cast en <type>object</type></member>
   <member><literal>(unset)</literal> - cast en <type>NULL</type></member>
  </simplelist>

  <note>
   <para>
    <literal>(integer)</literal> est un alias du cast <literal>(int)</literal>.
    <literal>(boolean)</literal> est un alias du cast <literal>(bool)</literal>.
    <literal>(binary)</literal> est un alias du cast <literal>(string)</literal>.
    <literal>(double)</literal> et <literal>(real)</literal> sont des alias du
    cast <literal>(float)</literal>.
    Ces casts n'utilisent pas le nom de type canonique est ne sont pas recommandé.
   </para>
  </note>

  <warning>
   <simpara>
    L'alias de cast <literal>(real)</literal> est obsolète à partir de PHP 8.0.0.
   </simpara>
  </warning>

  <warning>
   <simpara>
    Le cast <literal>(unset)</literal> a été rendu obsolète à partir de PHP 7.2.0.
    À noter que le cast <literal>(unset)</literal> est identique à assigner la
    valeur <type>NULL</type> à une variable ou un appel.
    Le cast <literal>(unset)</literal> est supprimé à partir de PHP 8.0.0.
   </simpara>
  </warning>

  <caution>
   <simpara>
    Le cast <literal>(binary)</literal> et le préfixe <literal>b</literal>
    existe uniquement pour la compatibilité ascendante. Actuellement
    <literal>(binary)</literal> et <literal>(string)</literal> sont identique,
    mais ceci peut changer et ne devrait pas être invoqué.
   </simpara>
  </caution>

  <note>
   <para>
    Les espaces blancs sont ignoré à l'intérieur des parenthèses d'un cast.
    Ansi, les deux casts suivant sont équivalents :
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
?>
]]>
     </programlisting>
    </informalexample>
   </para>
  </note>

  <informalexample>
   <simpara>
    Cast de <type>string</type>s littérales et variables en
    <type>string</type>s binaires :
   </simpara>

   <programlisting role="php">
<![CDATA[
<?php
$binary = (binary) $string;
$binary = b"binary string";
?>
]]>
   </programlisting>
  </informalexample>

  <!-- TODO Remove or move into string context section? -->
  <note>
   <simpara>
    Au lieu de cast une variable en une <type>string</type>, il est également possible
    d'entourer la variable de guillemets doubles.
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$foo = 10;            // $foo is an integer
$str = "$foo";        // $str is a string
$fst = (string) $foo; // $fst is also a string

// This prints out that "they are the same"
if ($fst === $str) {
    echo "they are the same";
}
?>
]]>
    </programlisting>
   </informalexample>
  </note>

  <para>
   Il n'est pas forcément évident ce qui se produira exactement lors d'un casting
   entre certains types. Pour plus d'informations, voir ces sections :
   <simplelist>
    <member><link linkend="language.types.boolean.casting">Convertir en boolean</link></member>
    <member><link linkend="language.types.integer.casting">Convertir en integer</link></member>
    <member><link linkend="language.types.float.casting">Convertir en float</link></member>
    <member><link linkend="language.types.string.casting">Convertir en string</link></member>
    <member><link linkend="language.types.array.casting">Convertir en array</link></member>
    <member><link linkend="language.types.object.casting">Convertir en object</link></member>
    <member><link linkend="language.types.resource.casting">Convertir en resource</link></member>
    <member><link linkend="language.types.null.casting">Convertir en NULL</link></member>
    <member><link linkend="types.comparisons">Les tables de comparaison de type</link></member>
   </simplelist>
  </para>
 </sect2>

 <simplesect>
  <note>
   <simpara>
    Comme PHP prend en charge l'indexation dans les <type>string</type>s
    via des positions en utilisant la même syntaxe que l'indexation des <type>array</type>,
    l'exemple suivant est valable pour toutes les versions de PHP :
   </simpara>

   <para>
    De plus, puisque PHP supporte l'indexation des chaînes de caractères
    via des positions en utilisant la même syntaxe que pour les tableaux,
    l'exemple suivant est vrai pour toutes les versions de PHP :
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$a    = 'car'; // $a est une chaîne de caractères
$a[0] = 'b';   // $a est toujours une chaîne de caractères
echo $a;       // bar
?>
]]>
    </programlisting>
   </informalexample>

   <simpara>
    Voir la section sur l'<link linkend="language.types.string.substr">accès
    aux chaînes par caractères</link> pour plus d'informations.
   </simpara>
  </note>
 </simplesect>

</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
-->