archived-doc-fr/language/types/type-system.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: f908fff129bcd8ec1605658e06457cb04e5b2b51 Maintainer: pierrick Status: ready -->
<!-- Reviewed: no -->
<sect1 xml:id="language.types.type-system">
 <title>Système de type</title>

 <para>
  PHP utilise un système de type nominal avec une relation de sous-typage comportementale forte.
  La relation de sous-typage est vérifiée à la compilation, tandis que la vérification des types
  est vérifiée dynamiquement au moment de l'exécution.
 </para>

 <para>
  Le système de type de PHP supporte plusieurs types atomiques qui peuvent être composés ensemble
  pour créer des types plus complexes. Certains de ces types peuvent être écrits sous forme de
  <link linkend="language.types.declarations">déclaration de type</link>.
 </para>

 <sect2 xml:id="language.types.type-system.atomic">
  <title>Types atomiques</title>
  <para>
   Certains types atomiques sont des types qui sont étroitement intégrés au langage
   et ne peuvent être reproduits avec des types définis par l'utilisateur.
  </para>

  <para>
   La liste des types de base est la suivante :
   <itemizedlist>
    <listitem>
     <simpara>Types intégrés</simpara>
     <itemizedlist>
      <listitem>
       <simpara>
        Types scalaires :
       </simpara>
       <itemizedlist>
        <listitem>
         <simpara>type <type>bool</type></simpara>
        </listitem>
        <listitem>
         <simpara>type <type>int</type></simpara>
        </listitem>
        <listitem>
         <simpara>type <type>float</type></simpara>
        </listitem>
        <listitem>
         <simpara>type <type>string</type></simpara>
        </listitem>
       </itemizedlist>
      </listitem>
      <listitem>
       <simpara>type <type>array</type></simpara>
      </listitem>
      <listitem>
       <simpara>type <type>object</type></simpara>
      </listitem>
      <listitem>
       <simpara>type <type>resource</type></simpara>
      </listitem>
      <listitem>
       <simpara>type <type>never</type></simpara>
      </listitem>
      <listitem>
       <simpara>type <type>void</type></simpara>
      </listitem>
      <listitem>
       <simpara>
       <link linkend="language.types.relative-class-types">Types de classes relatives</link>:
       <type>self</type>, <type>parent</type>, et <type>static</type>
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        <link linkend="language.types.singleton">Types singletons</link>
       </simpara>
       <itemizedlist>
        <listitem>
         <simpara><type>false</type></simpara>
        </listitem>
        <listitem>
         <simpara><type>true</type></simpara>
        </listitem>
       </itemizedlist>
      </listitem>
      <listitem>
       <simpara>
        Types unitaires
       </simpara>
       <itemizedlist>
        <listitem>
         <simpara><type>null</type></simpara>
        </listitem>
       </itemizedlist>
      </listitem>
     </itemizedlist>
    </listitem>
    <listitem>
     <simpara>
      Types définis par l'utilisateur (généralement appelés classes-types)
     </simpara>
     <itemizedlist>
      <listitem>
       <simpara><link linkend="language.oop5.interfaces">Interfaces</link></simpara>
      </listitem>
      <listitem>
       <simpara><link linkend="language.oop5.basic.class">Classes</link></simpara>
      </listitem>
      <listitem>
       <simpara><link linkend="language.types.enumerations">Énumérations</link></simpara>
      </listitem>
     </itemizedlist>
    </listitem>
    <listitem>
     <simpara>type <type>callable</type></simpara>
    </listitem>
   </itemizedlist>
  </para>

  <sect3 xml:id="language.types.type-system.atomic.scalar">
   <title>Types scalaires</title>
   <simpara>
    Une valeur est considérée comme scalaire si elle est de type <type>int</type>,
    <type>float</type>, <type>string</type> ou <type>bool</type>.
   </simpara>
  </sect3>

  <sect3 xml:id="language.types.type-system.atomic.user-defined">
   <title>Types définis par l'utilisateur</title>
   <simpara>
    Il est possible de définir des types personnalisés avec des
    <link linkend="language.oop5.interfaces">interfaces</link>,
    des <link linkend="language.oop5.basic.class">classes</link> et des
    <link linkend="language.types.enumerations">énumérations</link>.
    Ceux-ci sont considérés comme des types définis par l'utilisateur, ou types de classe.
    Par exemple, une classe appelée <literal>Elephant</literal> peut être définie,
    puis des objets de type <literal>Elephant</literal> peuvent être instanciés,
     et une fonction peut demander un paramètre de type <literal>Elephant</literal>.
    </simpara>
   </sect3>
  </sect2>

  <sect2 xml:id="language.types.type-system.composite">
   <title>Types composites</title>
   <para>
    Il est possible de combiner plusieurs types atomiques en des types composites.
   PHP permet de combiner les types de la manière suivante :
  </para>

  <itemizedlist>
   <listitem>
    <simpara>
     Intersection de classes-types (interfaces et noms de classes).
    </simpara>
   </listitem>
   <listitem>
    <simpara>
     Union de types.
    </simpara>
   </listitem>
  </itemizedlist>

  <sect3 xml:id="language.types.type-system.composite.intersection">
   <title>Intersection de types</title>
   <para>
    Un type d'intersection accepte des valeurs qui satisfont plusieurs
    déclarations de type de classe, plutôt qu'une seule.
    Les types individuels qui forment le type d'intersection sont reliés par le symbole
    <literal>&amp;</literal>. Par conséquent, un type d'intersection composé
    des types <literal>T</literal>, <literal>U</literal> et
   <literal>V</literal> s'écrit <literal>T&amp;U&amp;V</literal>.
   </para>
  </sect3>

  <sect3 xml:id="language.types.type-system.composite.union">
   <title>Types d'union</title>
   <para>
    Un type union accepte des valeurs de plusieurs types différents,
    plutôt qu'un seul.
    Les types individuels qui forment le type d'union sont reliés par le symbole
    <literal>|</literal>. Par conséquent, un type d'union composé
    des types <literal>T</literal>, <literal>U</literal> et
    <literal>V</literal> s'écrit <literal>T|U|V</literal>.
    Si l'un des types est un type d'intersection, il doit être mis entre
    parenthèses pour être écrit en <acronym>DNF</acronym>.
    <literal>T|(X&amp;Y)</literal>.
   </para>
  </sect3>
 </sect2>

 <sect2 xml:id="language.types.type-system.alias">
  <title>Alias de type</title>

  <para>
   PHP supporte deux alias de type : <type>mixed</type> et
   <type>iterable</type> qui correspond au type
   <link linkend="language.types.type-system.composite.union">type d'union</link>
   de <literal>object|resource|array|string|float|int|bool|null</literal>
   et <literal>Traversable|array</literal> respectivement.
  </para>

  <note>
   <simpara>
    PHP ne supporte pas les alias de type définis par l'utilisateur.
   </simpara>
  </note>
 </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
-->