doc-fr/language/expressions.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 4decb44c7141a97e348a1235bbb20d930d2baac0 Maintainer: yannick Status: ready -->
<!-- Reviewed: no -->
<chapter xml:id="language.expressions" xmlns="http://docbook.org/ns/docbook">
 <title>Les expressions</title>
 <simpara>
  Les expressions sont les pièces de construction les plus importants de PHP.
  En PHP, presque tout ce que vous écrivez est une expression. La manière la
  plus simple de définir une expression est : "tout ce qui a une valeur".
 </simpara>
 <simpara>
  Les formes les plus simples d'expressions sont les constantes et les variables.
  Lorsque vous écrivez <code>$a = 5</code>, vous assignez la valeur <code>5</code>
  à la variable <varname>$a</varname>. Bien évidemment, <code>5</code> vaut 5 ou,
  en d'autres termes, <code>5</code> est une expression avec pour valeur 5
  (dans ce cas, <code>5</code> est un entier constant).
 </simpara>
 <simpara>
  Après cette assignation, vous pouvez considérer que <varname>$a</varname>
  a pour valeur 5 et donc, écrire <code>$b = $a</code>, revient à écrire
  <code>$b = 5</code>. En d'autres termes, <varname>$a</varname> est une
  expression avec une valeur de 5. Si tout fonctionne correctement,
  c'est exactement ce qui arrive.
 </simpara>
 <para>
  Un exemple plus complexe concerne les fonctions. Par exemple, 
  considérons la fonction suivante :
  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
function foo ()
{
    return 5;
}
?>
]]>
   </programlisting>
  </informalexample>
 </para>
 <simpara>
  En supposant que vous êtes familiers avec le concept de fonction,
  (si ce n'est pas le cas, jetez un oil au chapitre concernant les
  <link linkend="language.functions">fonctions</link>),
  vous serez d'accord que <code>$c = foo()</code> est équivalent
  à <code>$c = 5</code>, et
  vous aurez tout à fait raison. Les fonctions sont des expressions qui
  ont la valeur de leur "valeur de retour". Si <code>foo()</code>
  renvoie 5, la valeur de l'expression <code>foo()</code> est 5.
  Habituellement, les fonctions ne font pas que
  renvoyer une valeur constante, mais réalisent des traitements.
 </simpara>
 <simpara>
  Bien sûr, les valeurs en PHP n'ont pas à être des
  valeurs numériques, comme c'est souvent le cas. PHP supporte quatre
  types de variables scalaires : les valeurs entières (&integer;), les nombres
  à virgule flottante (<type>float</type>), les chaînes de caractères
  (&string;) et les booléens (<type>bool</type>).
  (une variable scalaire est une variable que vous ne pouvez pas scinder en
  morceaux, au contraire des tableaux par exemple). PHP supporte aussi deux
  types composés : les tableaux et les objets. Chacun de ces types
  de variables peut être affecté ou renvoyé par une
  fonction.
 </simpara>
 <simpara>
  PHP va plus loin dans la gestion des expressions, comme le font d'autres
  langages. PHP est un langage orienté expression, dans le sens où
  presque tout est une expression. Considérons l'exemple dont nous avons
  déjà parlé, <code>$a = 5</code>. Il est facile de voir qu'il y a
  deux valeurs qui entrent en jeu ici, la valeur numérique constante <code>$a = 5</code>
  et la valeur de la variable <varname>$a</varname> qui est mise à jour à la
  valeur 5. Mais, la vérité est qu'il y a une autre valeur qui entre en jeu
  ici et c'est la valeur de l'assignation elle-même. L'assignation elle-même
  est assignée à une valeur, dans ce cas-là 5. En pratique,
  cela signifie que <code>$a = 5</code> est une expression qui a pour
  valeur 5. Donc, écrire <code>$b = ($a = 5)</code>
  revient à écrire <code>$b = ($a = 5)</code>
  (un point virgule marque la fin d'une instruction). Comme les assignations
  sont analysées de droite à gauche, vous pouvez aussi bien écrire
  <code>$b = $a = 5</code>.
 </simpara>
 <simpara>
  Un autre bon exemple du langage orienté expression est la
  pre-incrémentation et la post-incrémentation, (ainsi que
  la décrémentation). Les utilisateurs de PHP
  et ceux de nombreux autres langages sont habitués à
  la notation <code>variable++</code> et
  <code>variable--</code>.
  Ce sont les <link linkend="language.operators.increment">opérateurs
  d'incrémentation et de décrémentation</link>. PHP
  ajoute les possibilités d'incrémentation et de décrémentation
  comme c'est le cas dans le langage C. En PHP, comme en C, il y a deux
  types d'opérateurs d'incrémentation (pre-incrémentation et
  post-incrémentation). Les deux types d'opérateur
  d'incrémentation jouent le même rôle (c'est-à-dire qu'ils
  incrémentent la variable). La différence vient de la valeur de
  l'opérateur d'incrémentation. L'opérateur de
  pre-incrémentation, qui s'écrit <code>++$variable</code>, évalue
  la valeur incrémentée (PHP incrémente la variable
  avant de lire la valeur de cette variable, d'où le nom de
  pre-incrémentation). L'opérateur de post-incrémentation,
  qui s'écrit <code>$variable++</code> , évalue la valeur de la
  variable <varname>$variable</varname> avant de l'incrémenter (PHP incrémente la variable après
  avoir lu sa valeur, d'où le nom de post-incrémentation).
 </simpara>
 <simpara>
  Un type d'expression très commun est <link
  linkend="language.operators.comparison">l'expression de comparaison</link>. Ces
  expressions sont évaluées à 0 ou 1, autrement dit &false; ou &true;,
  respectivement. PHP supporte les opérateurs de comparaison &gt; (plus
  grand que), =&gt;  (plus grand ou égal), == (égal à), &lt; (plus petit que),
  &lt;= (plus petit ou égal). Ces expressions sont
  utilisées de manière courante dans les instructions conditionnelles, comme
  l'instruction <code>if</code>.
 </simpara>
 <simpara>
  Pour le dernier exemple d'expression, nous allons parler des combinaisons
  d'opérateurs/assignation. Vous savez que si vous voulez incrémenter la
  variable <varname>$a</varname> d'une unité, vous devez simplement écrire
  <code>$a++</code> ou <code>++$a</code>.
  Mais si vous voulez ajouter la valeur 3 à votre
  variable ? Vous pouvez écrire plusieurs fois <code>$a++</code>, mais
  ce n'est pas la meilleure des méthodes. Un pratique plus courante est
  d'écrire <code>$a = $a + 3</code>. L'expression <code>$a + 3</code>
  correspond à la valeur <varname>$a</varname> plus 3,
  et est de nouveau assignée à la variable <varname>$a</varname>.
  Donc, le résultat est l'incrémentation de 3 unités de la variable <varname>$a</varname>.
  En PHP, comme dans de nombreux autres langages comme le C, vous pouvez écrire cela de manière plus
  concise, manière qui avec le temps se révélera plus claire et plus rapide
  à comprendre. Ajouter 3 à la valeur de la variable <varname>$a</varname>
  peut s'écrire <code>$a += 3</code>. Cela signifie précisément : "on
  prend la valeur de la variable <varname>$a</varname>, on ajoute la valeur 3
  et on assigne cette valeur à la variable <varname>$a</varname>". Et pour
  être plus concis et plus clair, cette expression est plus rapide. La valeur
  de l'expression <code>$a += 3</code>, comme l'assignation d'une
  valeur quelconque, est la valeur assignée. Il est à noter que ce n'est pas 3,
  mais la combinaison de la valeur de la variable <varname>$a</varname> plus
  la valeur 3. (c'est la valeur qui est assignée à la variable
  <varname>$a</varname>). N'importe quel opérateur binaire
  peut utiliser ce type d'assignation, par exemple <code>$a -= 5</code>
  (soustraction de 5 de la valeur de la variable <varname>$a</varname>),
  <code>$b *= 7</code> (multiplication de la valeur de la variable
  <varname>$b</varname> par 7).
 </simpara>
 <para>
  Il y a une autre expression qui peut paraître complexe si vous ne l'avez pas
  vue dans d'autres langages, l'opérateur conditionnel ternaire :
 </para>
 <para>
  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
$first ? $second : $third
?>
]]>
   </programlisting>
  </informalexample>
 </para>
 <para>
  Si la valeur de la première sous-expression est vraie (&true;)
  (différente de 0), alors la deuxième sous-expression est
  évaluée et constitue le résultat de l'expression
  conditionnelle. Sinon, c'est la troisième sous-expression qui est
  évaluée et qui constitue le résultat de l'expression.
 </para>
 <para>
  Les exemples suivants devraient vous permettre de mieux comprendre 
  la pre-incrémentation, la post-incrémentation
  et le concept des expressions en général :
 </para>
 <para>
  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
function double($i)
{
    return $i*2;
}

$b = $a = 5;        /* Assigne la valeur 5 aux variables $a et $b  */
$c = $a++;          /* Post-incrémentation de la variable $a et assignation de
                       la valeur à la variable $c */
$e = $d = ++$b;     /* Pre-incrémentation, et assignation de la valeur aux
                       variables $d et $e  */
/* à ce niveau, les variables $d et $e sont égales à 6 */
$f = double($d++);  /* assignation du double de la valeur de $d à la variable $f ($f vaut 12),
                       puis incrémentation de la valeur de $d  */
$g = double(++$e);  /* assigne deux fois la valeur de $e après
                       incrémentation, 2*7 = 14 to $g */
$h = $g += 10;      /* Tout d'abord, $g est incrémentée de 10, et donc $g vaut 24.
                       Ensuite, la valeur de $g, (24) est assignée à la variable $h,
                       qui vaut donc elle aussi 24. */
?>
]]>
   </programlisting>
  </informalexample>
 </para>
 <simpara>
  Au début de ce chapitre, nous avons dit que nous allions décrire les
  différents types d'instructions, et donc, comme promis, nous allons voir que
  les expressions peuvent être des instructions. Mais attention, toutes les
  expressions ne sont pas des instructions. Dans ce cas-là, une instruction
  est de la forme '<code>expr ;</code>', c'est-à-dire, une expression
  suivie par un point-virgule.
  Dans <code>$b = $a = 5;</code>, <code>$a = 5</code> est une expression valide,
  mais ce n'est pas une instruction en elle-même.
  <code>$b = $a = 5;</code> est une instruction valide.
 </simpara>
 <simpara>
  La dernière chose qui mérite d'être mentionnée est
  la véritable valeur des expressions. Lorsque vous faites des tests
  sur une variable, dans une boucle conditionnelle par exemple, cela ne vous
  intéresse pas de savoir quelle est la valeur exacte de l'expression.
  Mais vous voulez seulement savoir si le résultat signifie &true; ou &false;
  
  Les constantes &true; et &false; (insensible à la casse) sont les deux
  valeurs possibles pour un booléen. Lorsque nécessaire, une expression
  est automatiquement convertie en booléen. Lisez la
  <link linkend="language.types.typecasting">section sur le transtypage</link>
  pour plus de détails.
 </simpara>
 <simpara>
  PHP propose une implémentation complète et détaillée des expressions.
  PHP documente toutes ses expressions dans le manuel que vous êtes
  en train de lire. Les exemples qui vont suivre devraient vous donner une
  bonne idée de ce qu'est une expression et comment construire vos propres
  expressions. Dans tout ce qui va suivre, nous écrirons
  <varname>expr</varname> pour indiquer toute expression PHP valide.
 </simpara>
</chapter>

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