[PHP-DOC] cvs: phpdoc /fr/language operators.xml

[Damien Seguy]

dams            Tue Jul 17 13:31:08 2001 EDT

  Modified files:              
    /phpdoc/fr/language operators.xml 
  Log:
  Major typos chase plus adding of <>
  
Index: phpdoc/fr/language/operators.xml
diff -u phpdoc/fr/language/operators.xml:1.12 phpdoc/fr/language/operators.xml:1.13
--- phpdoc/fr/language/operators.xml:1.12       Thu Mar 29 09:44:40 2001
+++ phpdoc/fr/language/operators.xml    Tue Jul 17 13:31:08 2001
@@ -5,7 +5,7 @@
    <sect1 id="language.operators.arithmetic">
     <title>Les op&eacute;rateurs arithm&eacute;tiques</title>
     <simpara>
-      Vous rappelez vous des op&eacute;rations &eacute;l&eacute;mentaires
+      Vous rappelez-vous des op&eacute;rations &eacute;l&eacute;mentaires
       apprises &agrave; l'&eacute;cole ?
     </simpara>
     <table>
@@ -50,25 +50,25 @@
     <simpara>
      L'op&eacute;rateur de division ("/") retourne une valeur enti&egrave;re
      (le r&eacute;sultat d'une division enti&egrave;re) si les deux op&eacute;randes
-     sont entiers (ou bien des cha&icirc;nes converties en entiers.
+     sont entiers (ou bien des cha&icirc;nes converties en entier.
      Si l'un des op&eacute;randes est un nombre &agrave; virgule flottante,
      ou bien le r&eacute;sultat d'une op&eacute;ration qui retourne une valeur
      non enti&egrave;re, un nombre &agrave; virgule flottante sera retourn&eacute;.
     </simpara>
    </sect1>
    <sect1 id="language.operators.assignment">
-    <title>Les op&eacute;rateurs d'assignement</title>
+    <title>Les op&eacute;rateurs d'assignation</title>
     <simpara>
-     L'op&eacute;rateurs d'assignement le plus simple est le signe "=".
+     L'op&eacute;rateur d'assignation le plus simple est le signe "=".
      Le premier r&eacute;flexe est de penser que ce signe veut dire
      "&eacute;gal &agrave;". Ce n'est pas le cas. Il signifie que
      l'op&eacute;rande de gauche se voit affecter la valeur de
      l'expression qui est &agrave; droite du signe &eacute;gal.
     </simpara>
     <para>
-     La valeur d'une expression d'assignement est la valeur
+     La valeur d'une expression d'assignation est la valeur
      assign&eacute;e. Par exemple, la valeur de l'expression
-     '$a = 3' est la valeur 3. Cela permet de faire d'utiliser
+     '$a = 3' est la valeur 3. Cela permet d'utiliser
      des astuces telles que :
      <informalexample>
       <programlisting role="php">
@@ -79,7 +79,7 @@
      </informalexample>
     </para>
     <para>
-     En plus du simple op&eacute;rateur d'assignement, il existe des
+     En plus du simple op&eacute;rateur d'assignation, il existe des
      "op&eacute;rateurs combin&eacute;s" pour tous les op&eacute;rateurs
      arithm&eacute;tiques et pour les op&eacute;rateurs sur les
      cha&icirc;nes de caract&egrave;res. Cela permet d'utiliser
@@ -102,17 +102,17 @@
      </informalexample>
     </para>
    <para>
-       On peut noter que l'assignement copie le contenu de la variable originale
-       dans la nouvelle (assignement par valeur), ce qui fait que les changements
+       On peut noter que l'assignation copie le contenu de la variable originale
+       dans la nouvelle variable (assignation par valeur), ce qui fait que les 
+changements
        de valeur d'une variable ne modifieront pas la valeur de l'autre. Cela peut
        se rev&eacute;ler important lors de la copie d'un grand tableau
-       durant une boucle. PHP 4 supporte aussi l'assignement par
+       durant une boucle. PHP 4 supporte aussi l'assignation par
        r&eacute;f&eacute;rence, en utilisant la syntaxe
        <computeroutput>$var = &amp;$othervar;</computeroutput>, mais ce
-       n'&eacute;tait pas possible en PHP 3. 'L'assignement par
+       n'&eacute;tait pas possible en PHP 3. 'L'assignation par
        r&eacute;f&eacute;rence' signifie que les deux variables contiennent les
        m&ecirc;mes donn&eacute;es, et que la modification de l'une affecte
-       l'autre. D'un autre cot&eacute;, la recopie est tr&egrave;s rapide.
+       l'autre. D'un autre c&ocirc;t&eacute;, la recopie est tr&egrave;s rapide.
    </para>
   </sect1>
    <sect1 id="language.operators.bitwise">
@@ -126,9 +126,9 @@
      <tgroup cols="3">
       <thead>
        <row>
-        <entry>exemple</entry>
-        <entry>nom</entry>
-        <entry>r&eacute;sultat</entry>
+        <entry>Exemple</entry>
+        <entry>Nom</entry>
+        <entry>R&eacute;sultat</entry>
        </row>
       </thead>
       <tbody>
@@ -220,6 +220,11 @@
         <entry>Vrai si $a est diff&eacute;rent de $b.</entry>
        </row>
        <row>
+        <entry>$a <> $b</entry>
+        <entry>Diff&eacute;rent</entry>
+        <entry>Vrai si $a est diff&eacute;rent de $b.</entry>
+       </row>
+       <row>
         <entry>$a &lt; $b</entry>
         <entry>Plus petit que</entry>
         <entry>Vrai si $a est plus petit strictement que $b.</entry>
@@ -262,15 +267,15 @@
   <sect1 id="language.operators.errorcontrol">
    <title>Op&eacute;rateur de contr&ocirc;le d'erreur</title>
    <simpara>
-    PHP supporte un op&eacute;rateur de contr&ocirc;le d'erreur : c'est &#64;. 
-    Lorsque cet op&eacute;rateur est ajout&eacute; en pr&eacute;fixe d'une 
-    expression PHP, les messages d'erreur qui peuvent &ecirc;tre 
+    PHP supporte un op&eacute;rateur de contr&ocirc;le d'erreur : c'est &#64;.
+    Lorsque cet op&eacute;rateur est ajout&eacute; en pr&eacute;fixe d'une
+    expression PHP, les messages d'erreur qui peuvent &ecirc;tre
     g&eacute;n&eacute;r&eacute;s par cette expression seront ignor&eacute;s.
    </simpara>
    <simpara>
     Si l'option <link linkend="ini.track-errors">track_errors</link>
     est activ&eacute;e, les messages d'erreurs g&eacute;n&eacute;r&eacute;s
-    par une expression seront sauv&eacute;s dans la variable globale 
+    par une expression seront sauv&eacute;s dans la variable globale
     $php_errormsg. Cette variable sera &eacute;cras&eacute;e &agrave;
     chaque erreur. Il faut alors la surveiller souvent pour pouvoir l'utiliser.
    </simpara>
@@ -278,26 +283,47 @@
     <informalexample>
      <programlisting role="php">
 &lt;?php
-/* Erreur SQL intentionnelle (trop de guillemets): */
-       $res = @mysql_query( "select nom, code from 'listedenom" ) or
-   die( "La requ&ecirc;te a &eacute;chou&eacute; : l'erreur est '$php_errormsg'" );
+/* Erreur intentionnelle (le fichier n'existe pas): */
+$my_file = @file ('non_persistent_file') or
+    die ("Impossible d'ouvrir le fichier : L'erreur est : '$php_errormsg'");
+// Cela fonctionne avec n'importe quelle expression, pas seulement les fonctions
+$value = @$cache[$key];
+// la ligne ci-dessus n'affichera pas d'alerte si la cl&eacute; $key du tableau 
+n'existe pas
 ?&gt;
      </programlisting>
     </informalexample>
    </para>
+   <note>
+    <simpara>
+     L'op&eacute;rateur &#64; ne fonctionne qu'avec les expressions. La r&egrave;gle
+     g&eacute;n&eacute;rale de fonctionnement est la suivante : si vous pouvez prendre
+     la valeur de quelquechose, vous pouvez le pr&eacute;fixer avec &#64;. Par 
+exemple,
+     vous pouvez ajouter &#64; aux variables, fonctions, &agrave;
+     <function>include</function>, aux constantes, etc... Vous ne pourrez
+     pas le faire avec des &eacute;l&eacute;ments de langage tels que les classes,
+     <literal>if</literal> et <literal>foreach</literal>, etc...
+    </simpara>
+   </note>
+   <note>
+    <simpara>
+     La plupart des fonctions d'acc&egrave;s aux bases de donn&eacute;es ne retournent
+     pas d'erreur PHP. Il faut y acc&eacute;der avec une fonction du type
+     base_de_donnees_get_error().
+    </simpara>
+   </note>
    <simpara>
-    Voir aussi 
+    Voir aussi
     <function>error_reporting</function>.
    </simpara>
   </sect1>
   <sect1 id="language.operators.execution">
    <title>Op&eacute;rateur d'ex&eacute;cutions</title>
    <para>
-       PHP supporte un op&eacute;rateur d'ex&eacute;cution : guillemets obliques 
-       ("``"). Notez bien la diff&eacute;rence avec les guillemets simples (sur 
+       PHP supporte un op&eacute;rateur d'ex&eacute;cution : guillemets obliques
+       ("``"). Notez bien la diff&eacute;rence entre les guillemets simples (sur
        la touche 4), et ceux-ci (sur la touche de la livre anglaise). PHP essaiera
        d'ex&eacute;cuter le contenu de ces guillemets obliques comme une commande
-       shell. Le r&eacute;sultat sera retourn&eacute; (i.e. : il ne sera pas 
+       shell. Le r&eacute;sultat sera retourn&eacute; (i.e. : il ne sera pas
        simplement envoy&eacute; &agrave; la sortie standard, il peut &ecirc;tre
        assign&eacute; &agrave; une variable).
        <informalexample>
@@ -314,21 +340,24 @@
      Cet op&eacute;rateur est d&eacute;sactiv&eacute; lorsque le
      <link linkend="ini.safe-mode">safe mode</link> est activ&eacute;.
     </para>
-   </note>   <para>
-       Voir aussi <function>system</function>,
-       <function>passthru</function>, <function>exec</function>,
-       <function>popen</function>, et
+   </note>
+   <para>
+       Voir aussi
+       <function>system</function>,
+       <function>passthru</function>,
+       <function>exec</function>,
+       <function>popen</function> et
        <function>escapeshellcmd</function>.
    </para>
   </sect1>
   <sect1 id="language.operators.increment">
-   <title>Op&eacute;rateurs d'incr&eacute;mentation/D&eacute;crementation</title>
+   <title>Op&eacute;rateurs 
+d'incr&eacute;mentation/D&eacute;cr&eacute;mentation</title>
    <para>
        PHP supporte les op&eacute;rateurs de pr&eacute; et post incr&eacute;mentation 
et
        d&eacute;cr&eacute;mentation, comme en C.
    </para>
     <table>
-     <title>Op&eacute;rateurs d'incrementation/D&eacute;crementation</title>
+     <title>Op&eacute;rateurs 
+d'incr&eacute;mentation/D&eacute;cr&eacute;mentation</title>
      <tgroup cols="3">
       <thead>
        <row>
@@ -346,7 +375,7 @@
        <row>
         <entry>$a++</entry>
         <entry>Post-incr&eacute;mente</entry>
-        <entry>Retourne $a, puis l'incr&eacute;mente $a de 1.</entry>
+        <entry>Retourne $a, puis l'incr&eacute;mente de 1.</entry>
        </row>
        <row>
         <entry>--$a</entry>
@@ -378,7 +407,7 @@
 $a = 5;
 echo "Devrait valoir  5: " . $a-- . "&lt;br&gt;\n";
 echo "Devrait valoir  4: " . $a . "&lt;br&gt;\n";
-echo "&lt;h3&gt;Pr&eacute;-d&eacute;crementation&lt;/h3&gt;";
+echo "&lt;h3&gt;Pr&eacute;-d&eacute;cr&eacute;mentation&lt;/h3&gt;";
 $a = 5;
 echo "Devrait valoir  4: " . --$a . "&lt;br&gt;\n";
 echo "Devrait valoir  4: " . $a . "&lt;br&gt;\n";
@@ -534,7 +563,7 @@
        </row>
        <row>
         <entry>droite</entry>
-        <entry>! ~ ++ -- (int) (double) (string) (array) (object) @</entry>
+        <entry>! ~ ++ -- (int) (double) (string) (array) (object) &#64;</entry>
        </row>
        <row>
         <entry>droite</entry>
@@ -555,9 +584,9 @@
        Il y a deux op&eacute;rateurs de cha&icirc;nes. Le premier
        est l'op&eacute;rateur de concat&eacute;nation ('.'), qui
        retourne la concat&eacute;nation de ses deux arguments.
-       Le second est l'op&eacute;rateur d'assignement
-       concat&eacute;nant ('.='). Reportez vous &agrave;
-       <link linkend="language.operators.assignment">Op&eacute;rateurs 
d'assignements</link>
+       Le second est l'op&eacute;rateur d'assignation
+       concat&eacute;nant ('.='). Reportez-vous &agrave;
+       <link linkend="language.operators.assignment">Op&eacute;rateurs 
+d'assignations</link>
        pour plus de d&eacute;tails.
    </simpara>
    <para>
@@ -565,10 +594,10 @@
         <programlisting role="php">
 &lt;?php
 $a = "Bonjour ";
-$b = $a . "Monde!"; 
+$b = $a . "Monde!";
 // $b contient "Bonjour Monde!"
 $a = "Bonjour ";
-$a = $a . "Monde!"; 
+$a = $a . "Monde!";
 // $a contient "Bonjour Monde!"
 ?&gt;
      </programlisting>