dams Fri Jan 12 02:56:51 2001 EDT
Modified files:
/phpdoc/fr/language constants.xml control-structures.xml
expressions.xml functions.xml oop.xml
operators.xml references.xml types.xml
variables.xml basic-syntax.xml
Log:
Typos fixed.
TRUE/FALSE -> LITERAL
Index: phpdoc/fr/language/constants.xml
diff -u phpdoc/fr/language/constants.xml:1.6 phpdoc/fr/language/constants.xml:1.7
--- phpdoc/fr/language/constants.xml:1.6 Tue Dec 26 05:23:05 2000
+++ phpdoc/fr/language/constants.xml Fri Jan 12 02:56:51 2001
@@ -1,25 +1,24 @@
<chapter id="language.constants">
<title>Les constantes</title>
-
<simpara>
- PHP définit un certain nombre de constantes et propose des
- mécanismes pour en définir d'autres durant l'exécution.
- Les constantes se comportent des variables, à l'exception du fait
- que leur valeur est définie grâce à la fonction
- <function>define</function>, et qu'elle ne peut pas être
+ PHP définit un certain nombre de constantes et propose des
+ mécanismes pour en définir d'autres durant l'exécution.
+ Les constantes se comportent des variables, à l'exception du fait
+ que leur valeur est définie grâce à la fonction
+ <function>define</function>, et qu'elle ne peut pas être
modifiée par la suite.
</simpara>
<para>
Les constantes prédéfinies (toujours disponibles) sont :
<variablelist>
- <varlistentry>
+ <varlistentry>
<term>__FILE__</term>
<listitem>
<simpara>
- Le nom du fichier qui est actuellement exécuté.
- Si cette constante est utilisée dans le cadre d'un fichier
- "inclus" (aprè utilisation de <function>require</function>),
- alors le nom du fichier inclus est renvoyé, et non le nom
+ Le nom du fichier qui est actuellement exécuté.
+ Si cette constante est utilisée dans le cadre d'un fichier
+ "inclus" (aprè utilisation de <function>require</function>),
+ alors le nom du fichier inclus est renvoyé, et non le nom
du fichier parent.
</simpara>
</listitem>
@@ -28,10 +27,10 @@
<term>__LINE__</term>
<listitem>
<simpara>
- Le numéro de la ligne qui est actuellement exécutée.
- Si cette constante est utilisée dans le cadre d'un fichier
+ Le numéro de la ligne qui est actuellement exécutée.
+ Si cette constante est utilisée dans le cadre d'un fichier
"inclus" (aprè utilisation de <function>require</function>),
- c'est la position dans le fichier inclus qui est renvoyé.
+ c'est la position dans le fichier inclus qui est renvoyé.
</simpara>
</listitem>
</varlistentry>
@@ -39,7 +38,7 @@
<term>PHP_VERSION</term>
<listitem>
<simpara>
- La chaîne de caractères de présentation de la
+ La chaîne de caractères de présentation de la
version du PHP qui est actuellement utilisée. Par exemple '4.0.0'.
</simpara>
</listitem>
@@ -48,24 +47,24 @@
<term>PHP_OS</term>
<listitem>
<simpara>
- Nom du système d'exploitation qui est utilisé par
+ Nom du système d'exploitation qui est utilisé par
la machine qui fait tourner le PHP. Par exemple, 'Linux'.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
- <term>TRUE</term>
+ <term><literal>TRUE</literal></term>
<listitem>
<simpara>
- La valeur TRUE.
+ La valeur <literal>TRUE</literal>.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
- <term>FALSE</term>
+ <term><literal>FALSE</literal></term>
<listitem>
<simpara>
- La valeur FALSE.
+ La valeur <literal>FALSE</literal>.
</simpara>
</listitem>
</varlistentry>
@@ -73,8 +72,8 @@
<term>E_ERROR</term>
<listitem>
<simpara>
- Dénote une erreur autre qu'une "parsing error" (erreur
d'analyse)
- qu'il n'est pas possible de corriger.
+ Dénote une erreur autre qu'une "parsing error" (erreur
+d'analyse)
+ qu'il n'est pas possible de corriger.
</simpara>
</listitem>
</varlistentry>
@@ -82,12 +81,12 @@
<term>E_WARNING</term>
<listitem>
<simpara>
- Dénote un contexte dans lequel le PHP trouve que quelque chose
- qui ne va pas. Mais l'exécution se poursuit tout de même.
- Ces alertes-là peuvent être récupérées
- par le script lui-même. Un exemple serait une expression
- régulière (regexp) invalide dans la fonction
- <function>ereg</function>.
+ Dénote un contexte dans lequel le PHP trouve que quelque chose
+ qui ne va pas. Mais l'exécution se poursuit tout de même.
+ Ces alertes-là peuvent être récupérées
+ par le script lui-même. Un exemple serait une expression
+ régulière (regexp) invalide dans la fonction
+ <function>ereg</function>.
</simpara>
</listitem>
</varlistentry>
@@ -95,8 +94,8 @@
<term>E_PARSE</term>
<listitem>
<simpara>
- L'analyseur a rencontré une forme syntaxique invalide
- dans le script. Correction de l'erreur impossible.
+ L'analyseur a rencontré une forme syntaxique invalide
+ dans le script. Correction de l'erreur impossible.
</simpara>
</listitem>
</varlistentry>
@@ -104,10 +103,10 @@
<term>E_NOTICE</term>
<listitem>
<simpara>
- Quelque chose s'est produit, qui peut être ou non une erreur.
+ Quelque chose s'est produit, qui peut être ou non une erreur.
L'exécution continue. Par exemple, le cas de guillemets doubles (")
- non refermés, ou bien la tentative d'accéder à
- une variable qui n'est pas encore affectée.
+ non refermés, ou bien la tentative d'accéder à
+ une variable qui n'est pas encore affectée.
</simpara>
</listitem>
</varlistentry>
@@ -121,6 +120,23 @@
seront notifiés.
</simpara>
</listitem>
+ </varlistentry>
+ </para>
+ <para>
+ Les constantes E_* sont généralement utilisées
+ avec la fonction <function>error_reporting</function>.
+ </para>
+ <para>
+ Vous pouvez définir d'autres constantes en utilisant la fonction
+ <function>define</function>.
+ </para>
+ <para>
+ Il est à noter que ce sont des constantes, et non pas des macros
+ comme en C. Seulement les données scalaires peuvent être
+ représentées par des constantes.
+ <example>
+ <title>Définition de constantes </title>
+ <programlisting role="php">
</varlistentry>
</variablelist>
</para>
@@ -143,6 +159,11 @@
define("CONSTANT", "Bonjour le monde.");
echo CONSTANT; // affiche "Bonjourle monde."
?>
+ </programlisting>
+ </example>
+ <example>
+ <title>Utilisation des constantes __FILE__ et __LINE__ </title>
+ <programlisting role="php">
</programlisting>
</example>
<example>
@@ -158,7 +179,6 @@
</example>
</para>
</chapter>
-
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
Index: phpdoc/fr/language/control-structures.xml
diff -u phpdoc/fr/language/control-structures.xml:1.2
phpdoc/fr/language/control-structures.xml:1.3
--- phpdoc/fr/language/control-structures.xml:1.2 Mon Nov 6 06:09:58 2000
+++ phpdoc/fr/language/control-structures.xml Fri Jan 12 02:56:51 2001
@@ -1,127 +1,130 @@
<chapter id="control-structures">
<title>Les structures de contrôle</title>
-
<simpara>
- Tous les scripts PHP sont une suite d'instructions. Une instruction
+ Tous les scripts PHP sont une suite d'instructions. Une instruction
peut être une assignation, un appel de fonction, une instruction
conditionnelle ou bien une instruction qui ne fait rien (une instruction
- vide). Une instruction se termine habituellement par un point virgule
- (";"). De plus, plusieurs instructions peuvent être
- regroupées en bloc, délimité par des
- accolades ("{}"). Un bloc est considéré comme une instruction.
- Les différents types d'instruction sont décrits dans ce
+ vide). Une instruction se termine habituellement par un point virgule
+ (";"). De plus, plusieurs instructions peuvent être
+ regroupées en bloc, délimité par des
+ accolades ("{}"). Un bloc est considéré comme une instruction.
+ Les différents types d'instruction sont décrits dans ce
chapitre.
</simpara>
-
<sect1 id="control-structures.if">
<title><literal>if</literal></title>
<para>
- L'instruction <literal>if</literal> est une des plus importantes
- instructions de tous les langages, PHP inclus. Elle permet
- l'exécution conditionnelle d'une partie de code. Les
- fonctionnalités de l'instruction <literal>if</literal>
+ L'instruction <literal>if</literal> est une des plus importantes
+ instructions de tous les langages, PHP inclus. Elle permet
+ l'exécution conditionnelle d'une partie de code. Les
+ fonctionnalités de l'instruction <literal>if</literal>
sont les mêmes en PHP qu'en C :
<informalexample>
- <programlisting>
-if (expr)
- statement
+ <programlisting role="php">
+<?php
+if (expression)
+ commandes
+?>
</programlisting>
</informalexample>
</para>
<simpara>
- Comme nous l'avons vu dans le paragraphe consacré aux expressions,
- <replaceable>expr</replaceable> est évaluée à
- sa vraie valeur. Si l'expression <replaceable>expr</replaceable> est
- <literal>TRUE</literal>, PHP exécutera l'instruction et si elle
+ Comme nous l'avons vu dans le paragraphe consacré aux expressions,
+ <replaceable>expr</replaceable> est évaluée à
+ sa vraie valeur. Si l'expression <replaceable>expr</replaceable> est
+ <literal>TRUE</literal>, PHP exécutera l'instruction et si elle
est <literal>FALSE</literal>, l'instruction sera ignorée.
</simpara>
<para>
- L'exemple suivant affiche la phrase <computeroutput>a est plus grand
+ L'exemple suivant affiche la phrase <computeroutput>a est plus grand
que b</computeroutput> si <replaceable>$a</replaceable> est plus grand
que <replaceable>$b</replaceable>:
-
<informalexample>
<programlisting role="php">
+<?php
if ($a > $b)
print "a est plus grand que b";
+?>
</programlisting>
</informalexample>
</para>
<para>
- Souvent, vous voulez que plusieurs instructions soient
- exécutées après un branchement conditionnel. Bien
- évidemment, il n'est pas obligatoire de répéter
+ Souvent, vous voulez que plusieurs instructions soient
+ exécutées après un branchement conditionnel. Bien
+ évidemment, il n'est pas obligatoire de répéter
l'instruction conditonnelle autant de fois que vous avez d'instructions
à exécuter. A la place, vous pouvez rassembler toutes les
- instructions dans un bloc. L'exemple suivant affiche <computeroutput>a
- est plus grand que b</computeroutput>, et assigne la valeur de la
- variable <replaceable>$a</replaceable> à la variable
+ instructions dans un bloc. L'exemple suivant affiche <computeroutput>a
+ est plus grand que b</computeroutput>, et assigne la valeur de la
+ variable <replaceable>$a</replaceable> à la variable
<replaceable>$b</replaceable>:
-
<informalexample>
<programlisting role="php">
+<?php
if ($a > $b) {
print "a est plus grand que b";
$b = $a;
}
+?>
</programlisting>
</informalexample>
</para>
<simpara>
- Vous pouvez imbriquer indéfiniment des instructions
- <literal>if</literal> les unes dans les autres, ce qui permet
- une grande flexibilité dans l'exécution d'une
+ Vous pouvez imbriquer indéfiniment des instructions
+ <literal>if</literal> les unes dans les autres, ce qui permet
+ une grande flexibilité dans l'exécution d'une
partie de code suivant un grand nombre de conditions.
</simpara>
</sect1>
-
<sect1 id="control-structures.else">
<title><literal>else</literal></title>
<para>
- Souvent, vous voulez exécuter une instruction si une
- condition est remplie, et une autre instruction si cette condition
- n'est pas remplie. C'est à cela que sert <literal>else</literal>.
- <literal>else</literal> fonctionne avec après un
- <literal>if</literal> et exécute les instructions
+ Souvent, vous voulez exécuter une instruction si une
+ condition est remplie, et une autre instruction si cette condition
+ n'est pas remplie. C'est à cela que sert <literal>else</literal>.
+ <literal>else</literal> fonctionne avec après un
+ <literal>if</literal> et exécute les instructions
correspondantes au cas oú l'expression du <literal>if</literal>
- est <literal>FALSE</literal>. Dans l'exemple suivant, ce bout de code
- affiche <computeroutput>a est plus grand que b</computeroutput> si la
- variable <replaceable>$a</replaceable> est plus grande que la variable
+ est <literal>FALSE</literal>. Dans l'exemple suivant, ce bout de code
+ affiche <computeroutput>a est plus grand que b</computeroutput> si la
+ variable <replaceable>$a</replaceable> est plus grande que la variable
<replaceable>$a</replaceable>, et <computeroutput>a est plus petit que b
- </computeroutput> sinon:
+ </computeroutput> sinon:
<informalexample>
<programlisting role="php">
+<?php
if ($a > $b) {
print "a est plus grand que b";
} else {
print "a est plus petit que b";
}
+?>
</programlisting>
</informalexample>
Les instructions après le <literal>else</literal> ne sont
- exécutées que si l'expression du <literal>if</literal>
+ exécutées que si l'expression du <literal>if</literal>
est <literal>FALSE</literal>, et si elle n'est pas suivi par l'expression
<literal>elseif</literal>.
</para>
</sect1>
-
<sect1 id="control-structures.elseif">
<title><literal>elseif</literal></title>
<para>
- <literal>elseif</literal>, comme son nom l'indique, est une combinaison
- de <literal>if</literal> et <literal>else</literal>. Comme l'expression
- <literal>else</literal>, il permet d'exécuter une instruction
- aprè un <literal>if</literal> dans le cas oú le "premier"
- if est évalué comme <literal>FALSE</literal>. Mais,
+ <literal>elseif</literal>, comme son nom l'indique, est une combinaison
+ de <literal>if</literal> et <literal>else</literal>. Comme l'expression
+ <literal>else</literal>, il permet d'exécuter une instruction
+ aprè un <literal>if</literal> dans le cas oú le "premier"
+ if est évalué comme <literal>FALSE</literal>. Mais,
à la différence de l'expression <literal>else</literal>,
- il n'exécutera l'instruction que si l'expression condionnelle
- <literal>elseif</literal> est évaluée comme
- <literal>TRUE</literal>. L'exemple suivant affichera
+ il n'exécutera l'instruction que si l'expression condionnelle
+ <literal>elseif</literal> est évaluée comme
+ <literal>TRUE</literal>. L'exemple suivant affichera
<computeroutput>a est plus grand que b</computeroutput>,
- <computeroutput>a est égal à b</computeroutput> ou
- <computeroutput>a est plus petit que b</computeroutput>:
+ <computeroutput>a est égal à b</computeroutput> ou
+ <computeroutput>a est plus petit que b</computeroutput>:
<informalexample>
<programlisting role="php">
+<?php
if ($a > $b) {
print "a est plus grand que b";
} elseif ($a == $b) {
@@ -129,188 +132,193 @@
} else {
print "a est plus petit que b";
}
+?>
</programlisting>
</informalexample>
</para>
<simpara>
Vous pouvez avoir plusieurs <literal>elseif</literal> qui s'imbriquent
les uns dans les autres, après un <literal>if</literal> initial.
- Le premier <literal>elseif</literal> qui sera évalué
- à <literal>TRUE</literal> sera exécuté. En PHP, vous
- pouvez aussi écrire "else if" en deux mots et son comportement sera
+ Le premier <literal>elseif</literal> qui sera évalué
+ à <literal>TRUE</literal> sera exécuté. En PHP, vous
+ pouvez aussi écrire "else if" en deux mots et son comportement sera
identique à la version en un seul mot.
</simpara>
<simpara>
- L'expression <literal>elseif</literal> est exécutée
- seulement si le <literal>if</literal> précédent et tout
- autre <literal>elseif</literal> précédent est
- évalués comme <literal>FALSE</literal>, et que
+ L'expression <literal>elseif</literal> est exécutée
+ seulement si le <literal>if</literal> précédent et tout
+ autre <literal>elseif</literal> précédent est
+ évalués comme <literal>FALSE</literal>, et que
votre <literal>elseif</literal> est évalué à
<literal>TRUE</literal>.
</simpara>
</sect1>
-
<sect1 id="control-structures.alternative-syntax">
<title>Syntaxe alternative</title>
<para>
- Le PHP propose une autre manière de rassembler des
- instructions à l'intérieur d'un bloc, pour les
- fonctions de contrôle <literal>if</literal>,
- <literal>while</literal>, <literal>for</literal>, et
+ Le PHP propose une autre manière de rassembler des
+ instructions à l'intérieur d'un bloc, pour les
+ fonctions de contrôle <literal>if</literal>,
+ <literal>while</literal>, <literal>for</literal>, et
<literal>switch</literal>. Dans chaque cas, le principe
- est de remplacer l'accolade d'ouverture par deux points (:)
- et l'accolade de fermeture par, respectivement,
- <literal>endif;</literal>, <literal>endwhile;</literal>,
+ est de remplacer l'accolade d'ouverture par deux points (:)
+ et l'accolade de fermeture par, respectivement,
+ <literal>endif;</literal>, <literal>endwhile;</literal>,
<literal>endfor;</literal>, ou <literal>endswitch;</literal>.
<informalexample>
<programlisting role="php">
- <?php if ($a == 5): ?>
- A is equal to 5
- <?php endif; ?>
+<?php if ($a == 5): ?>
+ A vaut 5
+<?php endif; ?>
</programlisting>
</informalexample>
</para>
<simpara>
- Dans l'exemple ci-desssus, le block HTML "A = 5" est inclus
- à l'intérieur d'un <literal>if</literal> en
- utilisant cette nouvelle syntaxe. Ce code HTML ne sera
- affiché que si la variable $a est égale à 5.
+ Dans l'exemple ci-desssus, le block HTML "A = 5" est inclus
+ à l'intérieur d'un <literal>if</literal> en
+ utilisant cette nouvelle syntaxe. Ce code HTML ne sera
+ affiché que si la variable $a est égale à 5.
</simpara>
<para>
Cette autre syntaxe fonctionne aussi avec le <literal>else</literal> et
- <literal>elseif</literal>. L'exemple suivant montre une structure avec un
- <literal>if</literal>, un <literal>elsif</literal> et un
- <literal>else</literal> utilisant cette autre syntaxe:
+ <literal>elseif</literal>. L'exemple suivant montre une structure avec un
+ <literal>if</literal>, un <literal>elsif</literal> et un
+ <literal>else</literal> utilisant cette autre syntaxe:
<informalexample>
<programlisting role="php">
+<?php
if ($a == 5):
- print "a equals 5";
+ print "a égale 5";
print "...";
elseif ($a == 6):
- print "a equals 6";
+ print "a égale 6";
print "!!!";
else:
- print "a is neither 5 nor 6";
+ print "a ne vaut ni 5 ni 6";
endif;
+?>
</programlisting>
</informalexample>
</para>
<para>
Allez voir <link linkend="control-structures.while">while</link>,
- <link linkend="control-structures.for">for</link>, et
+ <link linkend="control-structures.for">for</link>, et
<link linkend="control-structures.if">if</link> pour d'autres exemples.
</para>
</sect1>
-
<sect1 id="control-structures.while">
<title><literal>while</literal></title>
<para>
- La boucle <literal>while</literal> est le moyen le plus
- simple d'implémenter une boucle en PHP. Cette boucle
+ La boucle <literal>while</literal> est le moyen le plus
+ simple d'implémenter une boucle en PHP. Cette boucle
se comporte de la même manière qu'en C.
- L'exemple le plus simple d'une boucle <literal>while</literal>
- est le suivant :
+ L'exemple le plus simple d'une boucle <literal>while</literal>
+ est le suivant :
<informalexample>
- <programlisting>
-while (expr) statement
+ <programlisting role="php">
+<?php
+while (expression) commandes
+?>
</programlisting>
</informalexample>
</para>
<simpara>
- La signification d'une boucle <literal>while</literal> est
- très simple. Le PHP exécute l'instruction tant
- que l'expression de la boucle <literal>while</literal> est
- évaluée comme <literal>TRUE</literal>. La valeur
- de l'expression est vérifiée à chaque
- début de boucle, et, si la valeur change durant
- l'exécution de l'instruction, l'exécution ne
- s'arrêtera qu'à la fin de l'itération
- (chaque fois que le PHP exécute l'instruction, on appelle
+ La signification d'une boucle <literal>while</literal> est
+ très simple. Le PHP exécute l'instruction tant
+ que l'expression de la boucle <literal>while</literal> est
+ évaluée comme <literal>TRUE</literal>. La valeur
+ de l'expression est vérifiée à chaque
+ début de boucle, et, si la valeur change durant
+ l'exécution de l'instruction, l'exécution ne
+ s'arrêtera qu'à la fin de l'itération
+ (chaque fois que le PHP exécute l'instruction, on appelle
cela une itération). De temps en temps, si l'expression du
- <literal>while</literal> est <literal>FALSE</literal> avant la
- première itération, l'instruction ne sera jamais
+ <literal>while</literal> est <literal>FALSE</literal> avant la
+ première itération, l'instruction ne sera jamais
exécutée.
</simpara>
<para>
- Comme avec le <literal>if</literal>, vous pouvez regrouper
- plusieurs instructions dans la même boucle
+ Comme avec le <literal>if</literal>, vous pouvez regrouper
+ plusieurs instructions dans la même boucle
<literal>while</literal> en les regroupant à l'intérieur
- de parenthèses ou en utilisant la syntaxe suivante:
+ de parenthèses ou en utilisant la syntaxe suivante:
<informalexample>
- <programlisting>
-while (expr): statement ... endwhile;
+ <programlisting role="php">
+<?php
+while (expression): commandes ... endwhile;
+?>
</programlisting>
</informalexample>
</para>
<para>
- Les exemples suivants sont identiques, et affichent tous les nombres
- de 1 à 10:
+ Les exemples suivants sont identiques, et affichent tous les nombres
+ de 1 à 10:
<informalexample>
- <programlisting>
+ <programlisting role="php">
+<?php
/* exemple 1 */
-
$i = 1;
while ($i <= 10) {
print $i++; /* La valeur affiche est $i avant l'incrémentation
(post-incrémentation) */
}
-
/* exemple 2 */
-
$i = 1;
while ($i <= 10):
print $i;
$i++;
endwhile;
+?>
</programlisting>
</informalexample>
</para>
</sect1>
-
<sect1 id="control-structures.do.while">
<title><literal>do..while</literal></title>
<simpara>
- Les boucles <literal>do..while</literal> ressemblent beaucoup
- aux boucles <literal>while</literal>, mais l'expression est
- testée à la fin de chaque itération plutôt
- qu'au début. La principale différence par rapport
- à la boucle <literal>while</literal> est que la
- première itération de la boucle
- <literal>do..while</literal> est toujours exécutée
- (l'expression n'est testée qu'à la fin de
+ Les boucles <literal>do..while</literal> ressemblent beaucoup
+ aux boucles <literal>while</literal>, mais l'expression est
+ testée à la fin de chaque itération plutôt
+ qu'au début. La principale différence par rapport
+ à la boucle <literal>while</literal> est que la
+ première itération de la boucle
+ <literal>do..while</literal> est toujours exécutée
+ (l'expression n'est testée qu'à la fin de
l'itération), ce qui n'est pas le cas lorsque vous
utilisez une boucle <literal>while</literal> (l'expression
est vérifiée au début de chaque itération).
</simpara>
<para>
Il n'y a qu'un syntaxe possible pour les boucles <literal>do..while</literal>:
-
<informalexample>
<programlisting role="php">
+<?php
$i = 0;
do {
print $i;
} while ($i>0);
+?>
</programlisting>
</informalexample>
</para>
<simpara>
- La boucle ci-dessus ne va être exécutée
- qu'une seule fois, car lorsque l'expression est
+ La boucle ci-dessus ne va être exécutée
+ qu'une seule fois, car lorsque l'expression est
évaluée, elle vaut <literal>FALSE</literal> (car
la variable $i n'est pas plus grande que 0) et l'exécution
de la boucle s'arrête.
</simpara>
<para>
Les utilisateurs familiers du C sont habitués à
- une utilisation différente des boucles
- <literal>do..while</literal> , qui permet de stopper
+ une utilisation différente des boucles
+ <literal>do..while</literal> , qui permet de stopper
l'exécution de la boucle au milieu des instructions, en
- l'encapsulant dans un <literal>do..while</literal>(0) la
- fonction <link
linkend="control-structures.break"><literal>break</literal></link>.
- Le code suivant montre une utilisation possible:
+ l'encapsulant dans un <literal>do..while</literal>(0) la
+ fonction <link
+linkend="control-structures.break"><literal>break</literal></link>.
+ Le code suivant montre une utilisation possible:
<informalexample>
<programlisting role="php">
+<?php
do {
if ($i < 5) {
print "i n'est pas suffisamment grand";
@@ -321,82 +329,78 @@
break;
}
print "i est bon";
-
...process i...
-
} while(0);
+?>
</programlisting>
</informalexample>
</para>
<simpara>
- Ne vous inquiétez pas si vous ne comprenez
- pas tout correctement. Vous pouvez écrire des scripts
- très très puissants sans utiliser
+ Ne vous inquiétez pas si vous ne comprenez
+ pas tout correctement. Vous pouvez écrire des scripts
+ très très puissants sans utiliser
cette fonctionnalité.
</simpara>
</sect1>
-
<sect1 id="control-structures.for">
<title><literal>for</literal></title>
<para>
- Les boucles <literal>for</literal> sont les boucles les plus complexes en PHP.
- Elles fonctionnent comme les boucles <literal>for</literal> du langage C.
- La syntaxe des boucles for est la suivante:
+ Les boucles <literal>for</literal> sont les boucles les plus complexes en PHP.
+ Elles fonctionnent comme les boucles <literal>for</literal> du langage C.
+ La syntaxe des boucles for est la suivante:
<informalexample>
- <programlisting>
+ <programlisting role="php">
+<?php
for (expr1; expr2; expr3) statement
+?>
</programlisting>
</informalexample>
</para>
<simpara>
La première expression (<replaceable>expr1</replaceable>) est
- évaluée (exécutée), quoi qu'il arrive au
+ évaluée (exécutée), quoi qu'il arrive au
début de la boucle.
</simpara>
<simpara>
- Au début de chaque itération, l'expression
- <replaceable>expr2</replaceable> est évaluée.
- Si l'évaluation vaut <literal>TRUE</literal>, la boucle
- continue et l'instruction est exécutée. Si
+ Au début de chaque itération, l'expression
+ <replaceable>expr2</replaceable> est évaluée.
+ Si l'évaluation vaut <literal>TRUE</literal>, la boucle
+ continue et l'instruction est exécutée. Si
l'évaluation vaut <literal>FALSE</literal>,
l'exécution de la boucle s'arrête.
</simpara>
<simpara>
- A la fin de chaque itération, l'expression
- <replaceable>expr3</replaceable> est évaluée
+ A la fin de chaque itération, l'expression
+ <replaceable>expr3</replaceable> est évaluée
(exécutée).
</simpara>
<simpara>
- Les expressions peuvent éventuellement être
+ Les expressions peuvent éventuellement être
laissées vides. Si l'expression <replaceable>expr2</replaceable>
- est laissée vide, cela signifie que c'est une boucle infinie
- (PHP considère implicitement qu'elle vaut TRUE, comme en C).
- Cela n'est pas vraiment très utile, à moins que vous
- souhaitiez terminer votre boucle par l'instruction conditionnelle
+ est laissée vide, cela signifie que c'est une boucle infinie
+ (PHP considère implicitement qu'elle vaut <literal>TRUE</literal>, comme
+en C).
+ Cela n'est pas vraiment très utile, à moins que vous
+ souhaitiez terminer votre boucle par l'instruction conditionnelle
<link linkend="control-structures.break"><literal>break</literal></link>.
</simpara>
<para>
- Considérons les exemples suivants. Tous affichent les chiffres de
- 1 à 10:
+ Considérons les exemples suivants. Tous affichent les chiffres de
+ 1 à 10:
<informalexample>
<programlisting role="php">
+<?php
/* exemple 1 */
-
for ($i = 1; $i <= 10; $i++) {
print $i;
}
-
/* exemple 2 */
-
for ($i = 1;;$i++) {
if ($i > 10) {
break;
}
print $i;
}
-
/* exemple 3 */
-
$i = 1;
for (;;) {
if ($i > 10) {
@@ -405,77 +409,79 @@
print $i;
$i++;
}
-
/* exemple 4 */
-
for ($i = 1; $i <= 10; print $i, $i++) ;
+?>
</programlisting>
</informalexample>
</para>
<simpara>
Bien évidemment, le premier exemple est le plus simple
- de tous (ou peut être le quatrième), mais vous
- pouvez aussi pensez qu'utiliser une expression vide dans une
+ de tous (ou peut être le quatrième), mais vous
+ pouvez aussi pensez qu'utiliser une expression vide dans une
boucle <literal>for</literal> peut être utile parfois.
</simpara>
<para>
- PHP supporte aussi la syntaxe alternative suivante pour les boucles
+ PHP supporte aussi la syntaxe alternative suivante pour les boucles
<literal>for</literal> :
<informalexample>
- <programlisting>
+ <programlisting role="php">
+<?php
for (expr1; expr2; expr3): statement; ...; endfor;
+?>
</programlisting>
</informalexample>
</para>
<para>
Les autres langages ont l'instruction <literal>foreach</literal>
pour accéder aux éléments d'un tableau. PHP 3
- ne dispose pas d'une telle fonction; PHP 4 en dispose (voir
+ ne dispose pas d'une telle fonction; PHP 4 en dispose (voir
<link linkend="control-structures.foreach">foreach</link>). En PHP 3,
- vous pouvez combiner <link linkend="control-structures.while">while</link>
- avec <function>list</function> et <function>each</function> pour
- obtenir le même résultat. Reportez vous aux exemples
+ vous pouvez combiner <link linkend="control-structures.while">while</link>
+ avec <function>list</function> et <function>each</function> pour
+ obtenir le même résultat. Reportez vous aux exemples
de la documentation.
</para>
-
</sect1>
<sect1 id="control-structures.foreach">
<title><literal>foreach</literal></title>
<para>
- PHP4 (mais pas PHP3) inclus une commande <literal>foreach</literal>,
- comme en Perl ou d'autres langages. C'est un moyen simple de passer
- en revue un tableau. Il y a deux syntaxes possibles : la seconde est
+ PHP 4 (mais pas PHP 3) inclus une commande <literal>foreach</literal>,
+ comme en Perl ou d'autres langages. C'est un moyen simple de passer
+ en revue un tableau. Il y a deux syntaxes possibles : la seconde est
une extension mineure mais pratique de la première:
<informalexample>
- <programlisting>
-foreach(array_expression as $value) statement
-foreach(array_expression as $key => $value) statement
+ <programlisting role="php">
+<?php
+foreach(array_expression as $value) commandes
+foreach(array_expression as $key => $value) commandes
+?>
</programlisting>
</informalexample>
</para>
<simpara>
- La première forme passe en revue le tableau
- <literal>array_expression</literal>. A chaque itération,
- la valeur de l'élément courant est assigné à
- <literal>$value</literal> et le pointeur interne de tableau est
- avancé d'un élément (ce qui fait qu'à
- la prochaîne itération, on accédera à
+ La première forme passe en revue le tableau
+ <literal>array_expression</literal>. A chaque itération,
+ la valeur de l'élément courant est assigné à
+ <literal>$value</literal> et le pointeur interne de tableau est
+ avancé d'un élément (ce qui fait qu'à
+ la prochaîne itération, on accédera à
l'élément suivant).
</simpara>
<simpara>
- La deuxième forme fait exactement la même chose, mais
- c'est la clé de l'élément courant qui est
- assigné à la variable <literal>$key</literal>.
+ La deuxième forme fait exactement la même chose, mais
+ c'est la clé de l'élément courant qui est
+ assigné à la variable <literal>$key</literal>.
</simpara>
<simpara>
- Lorsque <literal>foreach</literal> démare, le pointeur interne
- de fichier est automatiquement ramené au premier
+ Lorsque <literal>foreach</literal> démare, le pointeur interne
+ de fichier est automatiquement ramené au premier
élément du tableau. Cela signifie que vous n'aurez
pas à faire appel à <function>reset</function> avant
<literal>foreach</literal>.
</simpara>
<para>
- Vous pouvez remarquer que les exemples suivants fonctionnent de
+ Vous pouvez remarquer que les exemples suivants fonctionnent de
manière identique :
<informalexample>
<programlisting role="php">
@@ -483,7 +489,6 @@
while (list(, $value) = each ($arr)) {
echo "Valeur: $value<br>\n";
}
-
foreach ($arr as $value) {
echo "Valeur: $value<br>\n";
}
@@ -496,7 +501,6 @@
while (list($key, $value) = each ($arr)) {
echo "Clé: $key; Valeur: $value<br>\n";
}
-
foreach ($arr as $key => $value) {
echo "Clé: $key; Valeur: $value<br>\n";
}
@@ -504,60 +508,52 @@
</informalexample>
</para>
<para>
-Voici quelques exemples de plus :
+ Voici quelques exemples de plus :
<informalexample>
<programlisting role="php">
+<?php
/* exemple 1: valeur seule */
-
$a = array (1, 2, 3, 17);
-
foreach ($a as $v) {
print "Valeur courante de \$a: $v.\n";
}
-
/* exemple 1: valeur (avec clé associée) */
-
$a = array (1, 2, 3, 17);
-
$i = 0; /* pour affichage seulement*/
-
foreach($a as $v) {
print "\$a[$i] => $k.\n";
}
-
/* exemple 1: valeur et clé */
-
$a = array (
- "one" => 1,
- "two" => 2,
- "three" => 3,
- "seventeen" => 17
+ "un" => 1,
+ "deux" => 2,
+ "trois" => 3,
+ "dix-sept" => 17
);
-
foreach($a as $k => $v) {
print "\$a[$k] => $v.\n";
}
+?>
</programlisting>
</informalexample>
</para>
</sect1>
-
<sect1 id="control-structures.break">
<title><literal>break</literal></title>
-
<simpara>
- L'instruction <literal>break</literal> permet de sortir d'une structure
+ L'instruction <literal>break</literal> permet de sortir d'une structure
<literal>if</literal>, <literal>for</literal>, <literal>while</literal>, ou
<literal>switch</literal>.
</simpara>
<simpara>
<literal>break</literal> accepte un argument numérique optionnel
- qui vous indiquera combien de structures emboîtées ont
+ qui vous indiquera combien de structures emboîtées ont
été interrompues.
</simpara>
<para>
<informalexample>
<programlisting role="php">
+<?php
$i = 0;
while ($i < 10) {
if ($arr[$i] == "stop") {
@@ -565,9 +561,7 @@
}
$i++;
}
-
/* Utilisation de l'argument optionnel. */
-
$i = 0;
while ( ++$i ) {
switch ( $i ) {
@@ -581,22 +575,22 @@
break;
}
}
+?>
</programlisting>
</informalexample>
</para>
</sect1>
-
<sect1 id="control-structures.continue">
<title><literal>continue</literal></title>
<simpara>
- L'instruction <literal>continue</literal> est utilisée
- dans une boucle afin d'éluder les instructions de
- l'itération courante afin de passer directement à
- l'itération suivante.
+ L'instruction <literal>continue</literal> est utilisée
+ dans une boucle afin d'éluder les instructions de
+ l'itération courante afin de passer directement à
+ l'itération suivante.
</simpara>
<simpara>
- <literal>continue</literal> accepte un argument numérique
- optionnel qui vous indiquera combien de structures
+ <literal>continue</literal> accepte un argument numérique
+ optionnel qui vous indiquera combien de structures
emboîtées ont été ignorées.
</simpara>
<para>
@@ -608,7 +602,6 @@
}
fonction_quelconque($valeur);
}
-
$i = 0;
while ($i++ < 5) {
echo "Dehors<br>\n";
@@ -626,24 +619,23 @@
</informalexample>
</para>
</sect1>
-
<sect1 id="control-structures.switch">
<title><literal>switch</literal></title>
<simpara>
- L'instruction <literal>switch</literal> équivaut
- à une série d'instructions <literal>if</literal>.
- En de nombreuses occasions, vous aurez besoin de comparer
- la même variable (ou expression) avec un grand nombre
- de valeurs différentes, et d'exécuter
- différentes parties de code suivant la valeur
+ L'instruction <literal>switch</literal> équivaut
+ à une série d'instructions <literal>if</literal>.
+ En de nombreuses occasions, vous aurez besoin de comparer
+ la même variable (ou expression) avec un grand nombre
+ de valeurs différentes, et d'exécuter
+ différentes parties de code suivant la valeur
à laquelle elle est égale. C'est exactement
à cela que sert l'instruction <literal>switch</literal>.
- </simpara>
+ </simpara>
<para>
- L4es deux exemples suivants sont deux manières
- différentes d'écrire la même chose,
+ L4es deux exemples suivants sont deux manières
+ différentes d'écrire la même chose,
l'une en utilisant une séries de <literal>if</literal>,
- et l'autre en utilisant l'instruction <literal>switch</literal>:
+ et l'autre en utilisant l'instruction <literal>switch</literal>:
<informalexample>
<programlisting role="php">
if ($i == 0) {
@@ -655,7 +647,6 @@
if ($i == 2) {
print "i égale 2";
}
-
switch ($i) {
case 0:
print "i égale 0";
@@ -671,20 +662,20 @@
</informalexample>
</para>
<para>
- Il est important de comprendre que l'instruction
- <literal>switch</literal> exécute chacune des
+ Il est important de comprendre que l'instruction
+ <literal>switch</literal> exécute chacune des
clauses dans l'ordre. L'instruction <literal>switch</literal>
- est exécutée ligne par ligne. Au début,
- aucun code n'est exécuté. Seulement
- lorsqu'un <literal>case</literal> est vérifié,
- PHP exécute alors les instructions correspondantes.
+ est exécutée ligne par ligne. Au début,
+ aucun code n'est exécuté. Seulement
+ lorsqu'un <literal>case</literal> est vérifié,
+ PHP exécute alors les instructions correspondantes.
PHP continue d'exécuter les instructions jusqu'à
- la fin du bloc d'instructions du <literal>switch</literal>,
+ la fin du bloc d'instructions du <literal>switch</literal>,
ou bien dès qu'il trouve l'instruction <literal>break</literal>.
- Si vous ne pouvez pas utiliser l'instruction
- <literal>break</literal> à la fin de l'instruction
- <literal>case</literal>, PHP continuera à exécuter
- toutes les instructions qui suivent. Par exemple :
+ Si vous ne pouvez pas utiliser l'instruction
+ <literal>break</literal> à la fin de l'instruction
+ <literal>case</literal>, PHP continuera à exécuter
+ toutes les instructions qui suivent. Par exemple :
<informalexample>
<programlisting role="php">
switch ($i) {
@@ -699,29 +690,29 @@
</informalexample>
</para>
<simpara>
- Dans cet exemple, si $i est égal à 0, PHP va
- exécuter quand même toutes les instructions qui
- suivent. Si $i est égal à 1, PHP exécutera
- les deux dernières instructions. Et seulement si $i est
- égal à, vous obtiendrez le résultat
- escompté, c'est-à-dire, l'affiche de
- "i égal 2. Donc, l'important est de ne pas oublier
- l'instruction <literal>break</literal> (même si il est
- possible que vous l'omettiez dans certaines circonstances).
+ Dans cet exemple, si $i est égal à 0, PHP va
+ exécuter quand même toutes les instructions qui
+ suivent. Si $i est égal à 1, PHP exécutera
+ les deux dernières instructions. Et seulement si $i est
+ égal à, vous obtiendrez le résultat
+ escompté, c'est-à-dire, l'affiche de
+ "i égal 2. Donc, l'important est de ne pas oublier
+ l'instruction <literal>break</literal> (même si il est
+ possible que vous l'omettiez dans certaines circonstances).
</simpara>
<simpara>
Dans une commande <literal>switch</literal>, une condition n'est
- évaluée qu'une fois, est le résultat est
- comparé à chaque <literal>case</literal>.
- Dans une structure <literal>elseif</literal>, les conditions sont
- évaluées à chaque comparaison. Si votre
- condition est plus compliquée qu'une simple
- comparaison, ou bien fait partie d'une boucle,
- <literal>switch</literal> sera plus rapide.
+ évaluée qu'une fois, est le résultat est
+ comparé à chaque <literal>case</literal>.
+ Dans une structure <literal>elseif</literal>, les conditions sont
+ évaluées à chaque comparaison. Si votre
+ condition est plus compliquée qu'une simple
+ comparaison, ou bien fait partie d'une boucle,
+ <literal>switch</literal> sera plus rapide.
</simpara>
<para>
- La liste de commande d'un <literal>case</literal> peut
- être vide, auquel cas PHP utilisera la liste de
+ La liste de commande d'un <literal>case</literal> peut
+ être vide, auquel cas PHP utilisera la liste de
commandes du cas suivant.
<informalexample>
<programlisting role="php">
@@ -738,9 +729,9 @@
</informalexample>
</para>
<para>
- Un <literal>case</literal> spécial est
+ Un <literal>case</literal> spécial est
<literal>default</literal>. Ce cas est utilisé lorsque tous
- les <literal>case</literal> ont échoués. Par exemple :
+ les <literal>case</literal> ont échoués. Par exemple :
<informalexample>
<programlisting role="php">
switch ($i) {
@@ -760,15 +751,15 @@
</informalexample>
</para>
<para>
- Une autre chose à mentionner est que l'instruction
+ Une autre chose à mentionner est que l'instruction
<literal>case</literal> peut être une expression à
- de type scalaire, c'est-à-dire nombre entier, nombre
+ de type scalaire, c'est-à-dire nombre entier, nombre
à virgule flottante et chaîne de caractère.
Les tableaux sont sans interêt dans ce contexte-là.
</para>
<para>
- La syntaxe alternative pour cette structure de contrôle est
- la suivante : pour plus d'informations, voir
+ La syntaxe alternative pour cette structure de contrôle est
+ la suivante : pour plus d'informations, voir
<link linkend="control-structures.alternative-syntax">syntaxes
alternatives</link>).
<informalexample>
<programlisting role="php">
@@ -789,54 +780,53 @@
</informalexample>
</para>
</sect1>
-
<sect1 id="function.require">
<title><function>require</function></title>
<simpara>
- La commande <function>require</function> se remplace elle même
- par le contenu du fichier spécifié, comme les
+ La commande <function>require</function> se remplace elle même
+ par le contenu du fichier spécifié, comme les
préprocesseurs C le font avec la commande <literal>#include</literal>.
</simpara>
<simpara>
- Il est important de noter que lorsqu'un fichier est
- <function>include</function> ou <function>require</function>,
+ Il est important de noter que lorsqu'un fichier est
+ <function>include</function> ou <function>require</function>,
les erreurs d'analyse apparaîtront en HTML tout au début
- du fichier, et l'analyse du fichier parent ne sera pas interrompue. Pour
+ du fichier, et l'analyse du fichier parent ne sera pas interrompue. Pour
cette raison, le code qui est dans le fichier doit être placé
entre <link linkend="language.basic-syntax.phpmode">les balises habituelles
de PHP</link>.
</simpara>
<simpara>
- <function>require</function> n'est pas vraiment une fonction PHP :
- c'est plus un instruction du langage. Elle ne fonctionne pas comme
- les fonctions standards. Par exemple, <function>require</function>
+ <function>require</function> n'est pas vraiment une fonction PHP :
+ c'est plus un instruction du langage. Elle ne fonctionne pas comme
+ les fonctions standards. Par exemple, <function>require</function>
ne peut pas contenir d'autres structures de contrôle. De plus,
il ne retourne aucune valeur. Lire une valeur retournée par un
<function>require</function> retourne une erreur
- d'analyse.
+ d'analyse.
</simpara>
<simpara>
- Contrairement à <function>include</function>,
- <function>require</function> va <emphasis>toujours</emphasis> lire dans
- le fichier cible, même si la ligne n'est jamais
- exécutée. Si vous souhaitez une inclusion
- conditionnelle, utilisez <function>include</function>. La
- condition ne va jamais affecter <function>require</function>.
+ Contrairement à <function>include</function>,
+ <function>require</function> va <emphasis>toujours</emphasis> lire dans
+ le fichier cible, même si la ligne n'est jamais
+ exécutée. Si vous souhaitez une inclusion
+ conditionnelle, utilisez <function>include</function>. La
+ condition ne va jamais affecter <function>require</function>.
Cependant, si la ligne de <function>require</function>
n'est jamais exécutée, le code du fichier ne
le sera jamais non plus.
</simpara>
<simpara>
- Les boucles n'affectent pas le comportement de
- <function>require</function>. Même si le code
- contenu dans le fichier source est appelé dans la boucle,
- <function>require</function> n'est exécuté qu'une
+ Les boucles n'affectent pas le comportement de
+ <function>require</function>. Même si le code
+ contenu dans le fichier source est appelé dans la boucle,
+ <function>require</function> n'est exécuté qu'une
fois.
</simpara>
<para>
- Cela signifie qu'on ne peut pas mettre un
- <function>require</function> dans une boucle, et s'attendre
- à ce qu'il inclue du code à chaque itération.
+ Cela signifie qu'on ne peut pas mettre un
+ <function>require</function> dans une boucle, et s'attendre
+ à ce qu'il inclue du code à chaque itération.
Pour cela, il faut utiliser <function>include</function>.
<informalexample>
<programlisting role="php">
@@ -846,15 +836,14 @@
</para>
<para>
Attention : <function>include</function> et
- <function>require</function> ajoute le contenu du fichier cible
- dans le script lui-même. Elle n'utilise pas le protocole
- HTTP ou tout autre protocole. Toute variable qui est dans le
- champs du script sera accessible dans le fichier d'inclusion,
+ <function>require</function> ajoute le contenu du fichier cible
+ dans le script lui-même. Elle n'utilise pas le protocole
+ HTTP ou tout autre protocole. Toute variable qui est dans le
+ champs du script sera accessible dans le fichier d'inclusion,
et vice versa.
<informalexample>
<programlisting role="php">
require ("file.inc?varone=1&vartwo=2"); /* Ne fonctionne pas. */
-
$varone = 1;
$vartwo = 2;
require ("file.inc"); /* $varone et $vartwo seront accessible à file.inc */
@@ -862,106 +851,106 @@
</informalexample>
</para>
<simpara>
- Ne vous laissez pas abuser par le fait que vous pouvez
- requérir ou inclure des fichiers via HTTP en
- utilisant la fonctionnalité de
+ Ne vous laissez pas abuser par le fait que vous pouvez
+ requérir ou inclure des fichiers via HTTP en
+ utilisant la fonctionnalité de
<link linkend="features.remote-files">gestion des fichiers distants</link>
ce qui est au dessus reste vrai.
</simpara>
<simpara>
- En PHP3, il est possible d'exécuter une commande
- <literal>return</literal> depuis un fichier inclus, tant
- que cette commande intervient au niveau global du fichier
+ En PHP 3, il est possible d'exécuter une commande
+ <literal>return</literal> depuis un fichier inclus, tant
+ que cette commande intervient au niveau global du fichier
inclus. Elle ne doit intervenir dans aucun bloc (entre accolade {}).
- En PHP4, cette possibilité a été
+ En PHP 4, cette possibilité a été
supprimée. Si vous en avez besoin, utilisez plutôt
<function>include</function>.
</simpara>
</sect1>
-
<sect1 id="function.include">
<title><function>include</function></title>
<simpara>
- La fonction <function>include</function> inclus et évalue le
+ La fonction <function>include</function> inclus et évalue le
fichier spécifié en argument.
</simpara>
<simpara>
- Il est important de noter que lorsqu'un fichier est
- <function>include</function> ou <function>require</function>,
- les erreurs d'analyse apparaîtront en HTML tout
- au début du fichier, et l'analyse du fichier
- parent ne sera pas interrompue. Pour cette raison, le code
- qui est dans le fichier doit être placé entre
- <link linkend="language.basic-syntax.phpmode">les balises
+ Il est important de noter que lorsqu'un fichier est
+ <function>include</function> ou <function>require</function>,
+ les erreurs d'analyse apparaîtront en HTML tout
+ au début du fichier, et l'analyse du fichier
+ parent ne sera pas interrompue. Pour cette raison, le code
+ qui est dans le fichier doit être placé entre
+ <link linkend="language.basic-syntax.phpmode">les balises
habituelles de PHP</link>.
</simpara>
<para>
- Cela a lieu à chaque fois que la fonction
- <function>include</function> est rencontrée. Donc vous
- vous pouvez utiliser la fonction <function>include</function>
- dans une boucle pour inclure un nombre infini de
+ Cela a lieu à chaque fois que la fonction
+ <function>include</function> est rencontrée. Donc vous
+ vous pouvez utiliser la fonction <function>include</function>
+ dans une boucle pour inclure un nombre infini de
fois un fichier, ou même des fichiers différents.
<informalexample>
<programlisting role="php">
+<?php
$files = array ('first.inc', 'second.inc', 'third.inc');
for ($i = 0; $i < count($files); $i++) {
include $files[$i];
}
+?>
</programlisting>
</informalexample>
</para>
<para>
- <function>include</function> diffère de
- <function>require</function> car le fichier inclus est
- ré-évaluée à chaque fois que la
- commande est exécutée, tandis que
- <function>require</function> est remplacée
- par le fichier cible lors de la première
- exécution, que son contenu soit utilisé
- ou non. De plus, cela se fait même si il
- est placé dans une structure conditionnelle,
+ <function>include</function> diffère de
+ <function>require</function> car le fichier inclus est
+ ré-évaluée à chaque fois que la
+ commande est exécutée, tandis que
+ <function>require</function> est remplacée
+ par le fichier cible lors de la première
+ exécution, que son contenu soit utilisé
+ ou non. De plus, cela se fait même si il
+ est placé dans une structure conditionnelle,
comme dans un <link linkend="control-structures.if">if</link>).
</para>
<para>
- Parce que la fonction <function>include</function> nécessite
+ Parce que la fonction <function>include</function> nécessite
une construction particulière, vous devez l'inclure dans un
bloc si elle est inclue dans une structure conditionnelle.
<informalexample>
<programlisting role="php">
+<?php
/* Ceci est faux, et ne fonctionnera pas ce qu'on attend. */
-
if ($condition)
include($file);
else
include($other);
-
/* Ceci est CORRECT. */
-
if ($condition) {
include($file);
} else {
include($other);
}
+?>
</programlisting>
</informalexample>
</para>
<simpara>
- En PHP3, il est possible d'exécuter une commande
- <literal>return</literal> depuis un fichier inclus, tant
- que cette commande intervient au niveau global du fichier
- inclus. Elle ne doit intervenir dans aucun bloc (entre accolade
- {}). En PHP4, cette possibilité a été
- supprimée. Cependant, PHP4 vous autorise à
- retourner des valeurs d'un fichier inclus. Vous pouvez
- traiter <function>include</function> comme une fonction
+ En PHP 3, il est possible d'exécuter une commande
+ <literal>return</literal> depuis un fichier inclus, tant
+ que cette commande intervient au niveau global du fichier
+ inclus. Elle ne doit intervenir dans aucun bloc (entre accolade
+ {}). En PHP 4, cette possibilité a été
+ supprimée. Cependant, PHP 4 vous autorise à
+ retourner des valeurs d'un fichier inclus. Vous pouvez
+ traiter <function>include</function> comme une fonction
normale, qui retourne une valeur. Mais cela génère
- une erreur d'analyse en PHP3.
+ une erreur d'analyse en PHP 3.
</simpara>
<example>
- <title><function>include</function> en PHP3 et PHP4</title>
+ <title><function>include</function> en PHP 3 et PHP 4</title>
<para>
- On suppose que le fichier <filename>test.inc</filename> existe,
- et est placé dans le même dossier que le fichier
+ On suppose que le fichier <filename>test.inc</filename> existe,
+ et est placé dans le même dossier que le fichier
principal :
<programlisting role="php">
<?;php
@@ -983,19 +972,19 @@
</programlisting>
</para>
<para>
- Lorsque <filename>main.html</filename> est appelé en PHP3,
- il va générer une erreur d'analyse (parse error)
+ Lorsque <filename>main.html</filename> est appelé en PHP 3,
+ il va générer une erreur d'analyse (parse error)
à la ligne 2; vous ne pouvez pas vous attendre à un
- retour sur une fonction <function>include</function> en PHP3. En
- PHP4, cependant,le résultat sera :
+ retour sur une fonction <function>include</function> en PHP 3. En
+ PHP 4, cependant,le résultat sera :
<screen>
Avant le retour
Ficher inclus : '27'
</screen>
</para>
<para>
- Supposons maintenant que <filename>main.html</filename> a
- été modifié et contient maintenant le
+ Supposons maintenant que <filename>main.html</filename> a
+ été modifié et contient maintenant le
code suivant :
<programlisting role="php">
<?;php
@@ -1005,45 +994,43 @@
</programlisting>
</para>
<para>
- En PHP4, l'affichage sera :
+ En PHP 4, l'affichage sera :
<screen>
Avant le retour
Retour dans le main.html
</screen>
- Au contraire, PHP3 affichera :
+ Au contraire, PHP 3 affichera :
<screen>
Avant le retour
27Retour dans le main.html
-
Parse error: parse error in /home/torben/public_html/phptest/main.html on line 5
</screen>
</para>
<para>
- L'erreur d'analyse ci-dessus est le résultat du fait que la commande
- <literal>return</literal> est dans un bloc qui n'est pas une fonction, dans
- <filename>test.inc</filename>. Lors que le return est sorti du bloc,
- l'affichage devient :
+ L'erreur d'analyse ci-dessus est le résultat du fait que la commande
+ <literal>return</literal> est dans un bloc qui n'est pas une fonction, dans
+ <filename>test.inc</filename>. Lors que le return est sorti du bloc,
+ l'affichage devient :
<screen>
Avant le retour
27Retour dans le main.html
</screen>
</para>
<para>
- Le '27' est du au fait que PHP3 ne supporte pas le <literal>return</literal>
+ Le '27' est du au fait que PHP 3 ne supporte pas le <literal>return</literal>
dans ces fichiers.
</para>
</example>
<para>
Il est important de noter que lorsqu'un fichier est <function>include</function>
- ou <function>require</function>, les erreurs d'analyse apparaîtront en
- HTML tout au début du fichier, et l'analyse du fichier parent ne sera
- pas interrompue. Pour cette raison, le code qui est dans le fichier doit
+ ou <function>require</function>, les erreurs d'analyse apparaîtront en
+ HTML tout au début du fichier, et l'analyse du fichier parent ne sera
+ pas interrompue. Pour cette raison, le code qui est dans le fichier doit
être placé entre <link linkend="language.basic-syntax.phpmode">
les balises habituelle de PHP</link>.
<informalexample>
<programlisting role="php">
include ("file.inc?varone=1&vartwo=2"); /* ne fonctionne pas. */
-
$varone = 1;
$vartwo = 2;
include ("file.inc"); /* $varone et $vartwo sont accessibles dans file.inc */
@@ -1051,27 +1038,26 @@
</informalexample>
</para>
<simpara>
- Ne vous laissez pas abuser par le fait que vous pouvez requérir
- ou inclure des fichiers via HTTP en utilisant la fonctionnalité
+ Ne vous laissez pas abuser par le fait que vous pouvez requérir
+ ou inclure des fichiers via HTTP en utilisant la fonctionnalité
de <link linkend="features.remote-files">gestion des fichiers distants
</link> ce qui est au dessus reste vrai.
</simpara>
<simpara>
- Voir aussi <function>readfile</function>, <function>require</function>
+ Voir aussi <function>readfile</function>, <function>require</function>
et <function>virtual</function>.
</simpara>
</sect1>
-
<sect1 id="function.require-once">
<title><function>require_once</function></title>
<para>
La commande <function>require_once</function> se remplace elle même
- par le fichier spécifié, un peu comme les commandes de
- préprocesseur C <literal>#include</literal>, et ressemble sur
- ce point à <function>require</function>. La principale
+ par le fichier spécifié, un peu comme les commandes de
+ préprocesseur C <literal>#include</literal>, et ressemble sur
+ ce point à <function>require</function>. La principale
différence est qu'avec <function>require_once</function>,
- vous êtes assurés que ce code ne sera ajouté
- qu'une seule fois, évitant de ce fait les redéfintions de
+ vous êtes assurés que ce code ne sera ajouté
+ qu'une seule fois, évitant de ce fait les redéfintions de
variables ou de fonctions, génératrices d'alertes.
</para>
<para>
@@ -1101,7 +1087,6 @@
dump_var($var);
}
}
-
// Une série de fonctions
?>
</programlisting>
@@ -1123,43 +1108,42 @@
?>
</programlisting>
</example>
- Lorsque vous exécutez le script ci dessus, le
+ Lorsque vous exécutez le script ci dessus, le
résultat sera (sous PHP 4.01pl2):
<informalexample>
- <programlisting>
+ <computeroutput>
GLOBALS ARE NICE
GLOBALS ARE NICE
-
Fatal error: Cannot redeclare causeerror() in utils.inc on line 5
- </programlisting>
+ </computeroutput>
</informalexample>
En modifiant <literal>foolib.inc</literal> et
- <literal>cause_errror_require.php</literal>
+ <literal>cause_errror_require.php</literal>
pour qu'elles utilisent <function>require_once</function>
au lieu de <function>require</function> et ne renommant le fichier
en <literal>avoid_error_require_once.php</literal>, on obtiend :
<example>
<title>foolib.inc (corrigé)</title>
<programlisting role="php">
-...
+<?php
require_once("utils.inc");
function showVar($var) {
-...
+?>
</programlisting>
</example>
<example>
<title>avoid_error_require_once.php</title>
<programlisting role="php">
-...
+<?php
require_once("foolib.inc");
require_once("utils.inc");
-$foo = array("1",array("complex","quaternion"));
-...
+$foo = array("1",array("complexe","quaternion"));
+?>
</programlisting>
</example>
L'exécution de ce script, sous PHP 4.0.1pl2, donne :
<informalexample>
- <programlisting>
+ <computeroutput>
LES GLOBALES SONT SYMPA
Ce code requiert utils.inc une deuxième fois, car il est requis
dans foolib.inc
@@ -1170,27 +1154,26 @@
[0] => 1
[1] => Array
(
- [0] => complex
+ [0] => complexe
[1] => quaternion
)
-
)
- </programlisting>
+ </computeroutput>
</informalexample>
</para>
<para>
- Notez aussi que, de la même manière que les
- préprocesseur traitent les <literal>#include</literal>,
- cette commande est exécutée au moment de la
- compilation, c'est à dire lorsque le script est
- analysée, et avant qu'il soit exécuté,
+ Notez aussi que, de la même manière que les
+ préprocesseur traitent les <literal>#include</literal>,
+ cette commande est exécutée au moment de la
+ compilation, c'est à dire lorsque le script est
+ analysée, et avant qu'il soit exécuté,
et ne doit pas être utilisée pour insérer
- des données dynamiques liées à
- l'éxécution. Il vaut alors mieux utiliser
+ des données dynamiques liées à
+ l'éxécution. Il vaut alors mieux utiliser
<function>include_once</function> ou <function>include</function>.
</para>
<para>
- Pour plus d'exemles avec <function>require_once</function> et
+ Pour plus d'exemples avec <function>require_once</function> et
<function>include_once</function>, jetez un oeil dans le code de PEAR
inclus dans la dernière distribution de PHP.
</para>
@@ -1202,29 +1185,28 @@
et <function>virtual</function>.
</para>
</sect1>
-
<sect1 id="function.include-once">
<title><function>include_once</function></title>
<para>
- La commande <function>include_once</function> inclus et
- évalue le fichier spécifié durant
- l'exécution du script. Le comportement est similaire à
- <function>include</function>, mais la différence est que si
- le code a déjà été inclus, il ne le
+ La commande <function>include_once</function> inclus et
+ évalue le fichier spécifié durant
+ l'exécution du script. Le comportement est similaire à
+ <function>include</function>, mais la différence est que si
+ le code a déjà été inclus, il ne le
sera pas une seconde fois.
</para>
<para>
- Comme précisé dans la section
- <function>require_once</function>, la fonction
- <function>include_once</function> est utilisée de
- préférence lorsque le fichier doit être
- inclus ou évalué plusieurs fois dans un script,
+ Comme précisé dans la section
+ <function>require_once</function>, la fonction
+ <function>include_once</function> est utilisée de
+ préférence lorsque le fichier doit être
+ inclus ou évalué plusieurs fois dans un script,
ou bien lorsque vous voulez être sur qu'il ne sera inclus
- qu'une seule fois, pour éviter des redéfinitions
+ qu'une seule fois, pour éviter des redéfinitions
de fonction.
</para>
<para>
- Pour plus d'exemles avec <function>require_once</function> et
+ Pour plus d'exemples avec <function>require_once</function> et
<function>include_once</function>, jetez un oeil dans le code de PEAR
inclus dans la dernière distribution de PHP.
</para>
@@ -1236,9 +1218,7 @@
et <function>virtual</function>.
</para>
</sect1>
-
</chapter>
-
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
Index: phpdoc/fr/language/expressions.xml
diff -u phpdoc/fr/language/expressions.xml:1.1 phpdoc/fr/language/expressions.xml:1.2
--- phpdoc/fr/language/expressions.xml:1.1 Fri Jul 21 03:23:49 2000
+++ phpdoc/fr/language/expressions.xml Fri Jan 12 02:56:51 2001
@@ -1,212 +1,204 @@
- <chapter id="language.expressions">
- <title>Les expressions</title>
-
- <simpara>
- Les expressions sont la partie la plus importante du 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 "$a = 5", vous assignez la valeur '5' à la
variable $a.
- Bien évidemment, '5' vaut 5 ou, en d'autres termes, '5' est une
expresssion
- avec pour valeur 5 (dans ce cas, '5' est un intier constant).
- </simpara>
-
- <simpara>
- Après cette assignation, vous pouvez considérer que $a a pour
valeur 5 et
- donc, écrire $b = $a, revient à écrire $b = 5. En d'autres
termes, $a est
- une expression avec de valeur 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>
-function foo () {
- return 5;
-}
- </programlisting>
- </informalexample></para>
-
- <simpara>
- Considérant que vous êtes familier avec le concept de fonction, (si
ce n'est pas
- le cas, jetez un oeil au chapitre concernant les fonctions), vous serez d'accord
- que $c = foo() est équivalent à $c = 5, et vous aurez tout
à fait raison.
- Les fonctions sont des expressions qui ont la valeur de leur "valeur de retour".
- Si foo() renvoie 5, la valeur de l'expression 'foo()' est 5. Habituellement, les
- fonctions ne font pas que renvoyer une valeur constante mais réalisent
des
- traitements.
- </simpara>
-
- <simpara>
- Bien sur, les valeurs en PHP n'ont pas à être des valeurs
numériques, comme
- c'est souvent le cas. PHP supporte 3 types de variables scalaires : les valeurs
- entières, les nombres à virgule flottante et les chaînes de
caractères.
- (une variable scalaire est une variable que vous ne pouvez pas scinder en
- morceau, au contraire des tableaux par exemple). PHP supporte aussi deux types
- composés : les tableaux et les objets. Chacun de ces types de variables
peuvent
- être affectés ou renvoyés par une fonction.
- </simpara>
-
- <simpara>
- Les utilisateurs de PHP/FI 2 ne verront aucun changement. Malgré tout,
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é, '$a = 5'. Il
- est facile de voir que il y a deux valeurs qui entrent en jeux ici, la valeur
- numérique constante '5' et la valeur de la variable $a qui est mis
à 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'assignement elle-même. L'assignement lui-même
est assigné
- à une valeur, dans ce cas-là 5. En pratique, cela signifie que '$a
= 5' est une
- expression qui a pour valeur 5. Donc, en écrire '$b = ($a = 5)' revient
à écrire
- '$a = 5; $b = 5;' (un point virgule marque la fin d'une instruction). Comme les
- assignements sont analysés de droite à gauche, vous pouvez aussi
bien écrire
- '$b = $a = 5'.
- </simpara>
-
- <simpara>
- Un autre bon exemple du langage orienté expression est la
pré-incrémentation et
- la post-incrémentation, (ainsi que la décrémentation). Les
utilisateurs de PHP/FI 2
- et ceux de nombreux autres langages sont habitués à la notation
"variable++"
- et "variable--". Ce sont les opérateurs d'incrémentation et de
décrémentation.
- En PHP/FI 2, l'instruction '$a++' n'a aucune valeur (c'est-à-dire que ce
n'est pas
- une expression) et vous ne pouvez donc pas l'utiliser. 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
(pré-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'il incrémente la variable).
- La différence vient de la valeur de l'opérateur
d'incrémentation. L'opérateur de
- pré-incrémentation, qui s'écrit '++$variable',
évalue la valeur incrémentée
- (PHP incrémente la variable avant de lire la valeur de cette variable,
d'oú le
- nom de 'pré-incrémentation'). L'opérateur de
post-incrémentation, qui s'écrit
- '$variable++', évalue la valeur de la variable 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 l'expression de comparaison. Ces
expressions
- sont évaluées à 0 ou 1, autrement dit FALSE ou TRUE
(respectivement). PHP supporte
- les opérateurs de comparaison > (plus grand que), => (plus grand ou
égal),
- == (égal à), < (plus petit que), <= (plus petit ou égal).
Ces expressions sont
- utilisées de manière courante dans les instructions
conditionnelles, comme l'instruction
- <literal>if</literal>.
-</simpara>
-
- <simpara>
- Pour le dernier exemple d'expression, nous allons parler des combinaisons
- d'opérateurs/assignement. Vous savez que si vous voulez
incrémenter la variable
- $a d'une unité, vous devez simplement écrire '$a++'. Mais si vous
voulez ajouter
- la valeur '3' à votre variable ? Vous pouvez écrire plusieurs
fois '$a++', mais ce
- n'est pas la meilleure des méthodes. Un pratique plus courante est
d'écrire
- '$a = $a + 3'. L'expression '$a + 3' correspond à la valeur $a plus 3,
et est
- de nouveau assignée à la variable $a. Donc le résultat est
l'incrémentation de
- 3 unités. 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 $a
- peut s'écrire '$a += 3'. Cela signifie précisement : "on prend la
valeur
- de la variable $a, on ajoute la valeur 3 et on assigne cette valeur à
- la variable $a". Et pour être plus concis et plus clair, cette expression
est
- plus rapide. La valeur de l'expression '$a += 3', comme l'assignement 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 $a plus la valeur 3. (c'est la valeur
qui
- est assignée à la variable $a). N'importe quel opérateur
binaire peu utiliser ce
- type d'assignement, par exemple '$a -= 5' (soustraction de 5 de la valeur de la
- variable $a), '$b *= 7' (multiplication de la valeur de la variable $b par 7).
-</simpara>
-
- <para>
- Il y a une autre expression qui peut paraître complexe si vous ne l'avez
pas
- vu dans d'autre langage, l'opérateur conditionnel ternaire:
-
- <informalexample><programlisting>
-$first ? $second : $third
-</programlisting></informalexample>
-
- Si la valeur de la première sous-expression est vraie, (différente
de 0), alors la
- deuxième sous-expression est évaluée et constitue le
résultat de l'expression conditonnelle.
- Sinon, c'est la troisè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 pré-
et post-
- incrémentation et le concept des expressions en général:
-
- <informalexample>
- <programlisting>
-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; /* Pré-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
<emphasis>après</emphasis>
- 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 'expr'
';',
- c'est-à-dire, une expression suivie par un point virgule. L'expression
- '$b = $a = 5;', '$a = 5' est une valide, mais ce n'est pas une instruction en
- elle-même. '$b = $a = 5' 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 qu'elle
est
- la valeur exacte de l'expression. Mais vous voulez seulement savoir si le
résultat
- signifie TRUE ou FALSE (PHP n'a pas de type booléen). La véritable
valeur d'une
- expression en PHP est calculée de la même manière qu'en
Perl. Toute valeur
- numérique différente de 0 est considérée comme
étant TRUE. Une chaîne de
- caractères vide et la chaîne de caractère 0 sont
considérées comme FALSE.
- Toutes les autres valeurs sont vraies. Avec les types de variables
non-scalaires,
- (les tableaux et les objets), s'ils ne contiennent aucun élément,
renvoient
- <literal>FALSE</literal>, sinon, ils renvoient <literal>TRUE</literal>.
- </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 <replaceable>expr</replaceable> pour
indiquer
- tout 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
- sgml-parent-document:nil
- sgml-default-dtd-file:"../manual.ced"
- sgml-exposed-tags:nil
- sgml-local-catalogs:nil
- sgml-local-ecat-files:nil
- End:
- -->
+ <chapter id="language.expressions">
+ <title>Les expressions</title>
+ <simpara>
+ Les expressions sont la partie la plus importante du 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 "$a = 5", vous assignez la valeur '5' à la
+variable $a.
+ Bien évidemment, '5' vaut 5 ou, en d'autres termes, '5' est une expresssion
+ avec pour valeur 5 (dans ce cas, '5' est un intier constant).
+ </simpara>
+ <simpara>
+ Après cette assignation, vous pouvez considérer que $a a pour
+valeur 5 et
+ donc, écrire $b = $a, revient à écrire $b = 5. En d'autres
+termes, $a est
+ une expression avec de valeur 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">
+<?php
+function foo () {
+ return 5;
+}
+?>
+ </programlisting>
+ </informalexample>
+ </para>
+ <simpara>
+ Considérant que vous êtes familier avec le concept de fonction, (si
+ce n'est pas
+ le cas, jetez un oeil au chapitre concernant les fonctions), vous serez d'accord
+ que $c = foo() est équivalent à $c = 5, et vous aurez tout
+à fait raison.
+ Les fonctions sont des expressions qui ont la valeur de leur "valeur de retour".
+ Si foo() renvoie 5, la valeur de l'expression 'foo()' est 5. Habituellement, les
+ fonctions ne font pas que renvoyer une valeur constante mais réalisent des
+ traitements.
+ </simpara>
+ <simpara>
+ Bien sur, les valeurs en PHP n'ont pas à être des valeurs
+numériques, comme
+ c'est souvent le cas. PHP supporte 3 types de variables scalaires : les valeurs
+ entières, les nombres à virgule flottante et les chaînes de
+caractères.
+ (une variable scalaire est une variable que vous ne pouvez pas scinder en
+ morceau, au contraire des tableaux par exemple). PHP supporte aussi deux types
+ composés : les tableaux et les objets. Chacun de ces types de variables
+peuvent
+ être affectés ou renvoyés par une fonction.
+ </simpara>
+ <simpara>
+ Les utilisateurs de PHP/FI 2 ne verront aucun changement. Malgré tout,
+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é, '$a = 5'. Il
+ est facile de voir que il y a deux valeurs qui entrent en jeux ici, la valeur
+ numérique constante '5' et la valeur de la variable $a qui est mis
+à 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'assignement elle-même. L'assignement lui-même
+est assigné
+ à une valeur, dans ce cas-là 5. En pratique, cela signifie que '$a
+= 5' est une
+ expression qui a pour valeur 5. Donc, en écrire '$b = ($a = 5)' revient
+à écrire
+ '$a = 5; $b = 5;' (un point virgule marque la fin d'une instruction). Comme les
+ assignements sont analysés de droite à gauche, vous pouvez aussi
+bien écrire
+ '$b = $a = 5'.
+ </simpara>
+ <simpara>
+ Un autre bon exemple du langage orienté expression est la
+pré-incrémentation et
+ la post-incrémentation, (ainsi que la décrémentation). Les
+utilisateurs de PHP/FI 2
+ et ceux de nombreux autres langages sont habitués à la notation
+"variable++"
+ et "variable--". Ce sont les opérateurs d'incrémentation et de
+décrémentation.
+ En PHP/FI 2, l'instruction '$a++' n'a aucune valeur (c'est-à-dire que ce
+n'est pas
+ une expression) et vous ne pouvez donc pas l'utiliser. 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
+(pré-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'il incrémente la variable).
+ La différence vient de la valeur de l'opérateur
+d'incrémentation. L'opérateur de
+ pré-incrémentation, qui s'écrit '++$variable',
+évalue la valeur incrémentée
+ (PHP incrémente la variable avant de lire la valeur de cette variable,
+d'oú le
+ nom de 'pré-incrémentation'). L'opérateur de
+post-incrémentation, qui s'écrit
+ '$variable++', évalue la valeur de la variable 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 l'expression de comparaison. Ces
+expressions
+ sont évaluées à 0 ou 1, autrement dit
+<literal>FALSE</literal> ou <literal>TRUE</literal> (respectivement). PHP supporte
+ les opérateurs de comparaison > (plus grand que), => (plus grand ou
+égal),
+ == (égal à), < (plus petit que), <= (plus petit ou égal).
+Ces expressions sont
+ utilisées de manière courante dans les instructions
+conditionnelles, comme l'instruction
+ <literal>if</literal>.
+ </simpara>
+ <simpara>
+ Pour le dernier exemple d'expression, nous allons parler des combinaisons
+ d'opérateurs/assignement. Vous savez que si vous voulez incrémenter
+la variable
+ $a d'une unité, vous devez simplement écrire '$a++'. Mais si vous
+voulez ajouter
+ la valeur '3' à votre variable ? Vous pouvez écrire plusieurs fois
+'$a++', mais ce
+ n'est pas la meilleure des méthodes. Un pratique plus courante est
+d'écrire
+ '$a = $a + 3'. L'expression '$a + 3' correspond à la valeur $a plus 3, et
+est
+ de nouveau assignée à la variable $a. Donc le résultat est
+ l'incrémentation de 3 unités. 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 $a
+ peut s'écrire '$a += 3'. Cela signifie précisement : "on prend la
+valeur
+ de la variable $a, on ajoute la valeur 3 et on assigne cette valeur à
+ la variable $a". Et pour être plus concis et plus clair, cette expression
+est
+ plus rapide. La valeur de l'expression '$a += 3', comme l'assignement 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 $a plus la valeur 3. (c'est la valeur qui
+ est assignée à la variable $a). N'importe quel opérateur
+binaire
+ peu utiliser ce type d'assignement, par exemple '$a -= 5' (soustraction de 5 de
+ la valeur de la variable $a), '$b *= 7' (multiplication de la valeur de la
+variable $b par 7).
+ </simpara>
+ <para>
+ Il y a une autre expression qui peut paraître complexe si vous ne l'avez pas
+ vu dans d'autre langage, l'opérateur conditionnel ternaire:
+ <informalexample>
+ <programlisting role="php">
+<?php
+$first ? $second : $third
+?>
+ </programlisting>
+ </informalexample>
+ Si la valeur de la première sous-expression est vraie, (différente
+de 0), alors la
+ deuxième sous-expression est évaluée et constitue le
+résultat de l'expression conditonnelle.
+ Sinon, c'est la troisè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 pré-
+et post-
+ incrémentation et le concept des expressions en général:
+ <informalexample>
+ <programlisting role="php">
+<?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; /* Pré-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
+<emphasis>après</emphasis>
+ 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 'expr' ';', c'est-à-dire, une expression suivie par un
+point-virgule.
+ L'expression '$b = $a = 5;', '$a = 5' est valide, mais ce n'est pas une
+instruction en
+ elle-même. '$b = $a = 5' 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 faîtes des tests sur
+ une variable, dans une boucle conditionnelle par exemple, cela ne vous
+ intéresse pas de savoir qu'elle est la valeur exacte de l'expression.
+ Mais vous voulez seulement savoir si le résultat signifie
+<literal>TRUE</literal> ou <literal>FALSE</literal>
+ (PHP n'a pas de type booléen). La véritable valeur d'une
+ expression en PHP est calculée de la même manière qu'en Perl.
+ Toute valeur numérique différente de 0 est considérée
+ comme étant <literal>TRUE</literal>. Une chaîne de caractères
+vide et la chaîne
+ de caractère 0 sont considérées comme
+<literal>FALSE</literal>. Toutes les autres
+ valeurs sont vraies. Avec les types de variables non-scalaires (les tableaux et
+les objets),
+ s'ils ne contiennent aucun élément, renvoient
+<literal>FALSE</literal>, sinon,
+ ils renvoient <literal>TRUE</literal>.
+ </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 <replaceable>expr</replaceable>
+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
+ sgml-parent-document:nil
+ sgml-default-dtd-file:"../manual.ced"
+ sgml-exposed-tags:nil
+ sgml-local-catalogs:nil
+ sgml-local-ecat-files:nil
+ End:
+ -->
Index: phpdoc/fr/language/functions.xml
diff -u phpdoc/fr/language/functions.xml:1.3 phpdoc/fr/language/functions.xml:1.4
--- phpdoc/fr/language/functions.xml:1.3 Wed Dec 13 05:51:00 2000
+++ phpdoc/fr/language/functions.xml Fri Jan 12 02:56:51 2001
@@ -6,10 +6,12 @@
une fonction peut être définie en utilisant la syntaxe suivante :
<informalexample>
<programlisting role="php">
+<?php
function foo ($arg_1, $arg_2, ..., $arg_n) {
echo "Exemple de fonction.\n";
return $retval;
}
+?>
</programlisting>
</informalexample>
</para>
@@ -137,17 +139,17 @@
ni une variable ou ni un membre de classe.
</simpara>
<para>
- Il est à noter que vous utilisez les arguments
- par défaut, la valeur par défaut
- doit se trouver du côté droit du
- signe '='; sinon, cela ne fonctionnera pas.
- Considérons le code suivant :
+ Il est à noter que vous utilisez les arguments par défaut,
+ la valeur par défaut doit se trouver du côté droit du
+ signe '='; sinon, cela ne fonctionnera pas. Considérons le code suivant :
<informalexample>
<programlisting role="php">
+<?php
function faireunyaourt ($type = "acidophilus", $flavour) {
return "Préparer un bol de $type $flavour.\n";
}
echo faireunyaourt ("framboise"); // ne fonctionne pas comme voulu
+?>
</programlisting>
</informalexample>
</para>
@@ -164,10 +166,12 @@
l'exemple suivant :
<informalexample>
<programlisting role="php">
+<?php
function faireunyaourt ($flavour, $type = "acidophilus") {
return "Préparer un bol de $type $flavour.\n";
}
echo faireunyaourt ("framboise"); // fonctionne comme voulu
+?>
</programlisting>
</informalexample>
</para>
@@ -179,9 +183,9 @@
</para>
</sect2>
<sect2 id="functions.variable-arg-list">
- <title>Variable-length argument lists</title>
+ <title>Nombre d'arguments variable</title>
<simpara>
- PHP 4 supporte le fonctions à nombre d'argument variable.
+ PHP 4 supporte les fonctions à nombre d'arguments variable.
C'est très simple à utiliser, avec les fonctions
<function>func_num_args</function>, <function>func_get_arg</function>,
et <function>func_get_args</function>.
@@ -223,8 +227,8 @@
</informalexample>
</para>
<para>
- Pour retourner une référence d'une fonction,&
- aussi bien dans la déclaration de la fonction que dans
+ Pour retourner une référence d'une fonction,&
+ aussi bien dans la déclaration de la fonction que dans
l'assignation de la valeur de retour.
<informalexample>
<programlisting role="php">
@@ -239,26 +243,25 @@
<sect1 id="functions.old-syntax">
<title><literal>old_function</literal></title>
<simpara>
- L'instruction <literal>old_function</literal> vous permet de
- déclarer une fonction en utilisant une syntaxe du type
- PHP/FI2 (au détail près que vous devez remplacer
- l'instruction 'function' par 'old_function'.)
+ L'instruction <literal>old_function</literal> vous permet de
+ déclarer une fonction en utilisant une syntaxe du type
+ PHP/FI2 (au détail près que vous devez remplacer
+ l'instruction 'function' par 'old_function'.)
</simpara>
<simpara>
- C'est une fonctionnalité obsolète et elle ne devrait
- être utilisée que dans le cadre de conversion de
- PHP/FI2 vers PHP 3
+ C'est une fonctionnalité obsolète et elle ne devrait
+ être utilisée que dans le cadre de conversion de
+ PHP/FI2 vers PHP 3
</simpara>
<warning>
<para>
- Les fonctions déclarées comme <literal>old_function</literal>
- ne peuvent pas être appelée à partir du code
- interne du PHP. Cela signifie, par exemple, que vous ne
- pouvez pas les utiliser avec des fonctions comme <function>usort</function>,
- <function>array_walk</function>, et
- <function>register_shutdown_function</function>.
- Vous pouvez contourner ce problème en écrivant une fonction
- d'encapsulation qui appelera la fonction <literal>old_function</literal>.
+ Les fonctions déclarées comme <literal>old_function</literal>
+ ne peuvent pas être appelée à partir du code
+ interne du PHP. Cela signifie, par exemple, que vous ne
+ pouvez pas les utiliser avec des fonctions comme <function>usort</function>,
+ <function>array_walk</function>, et
+<function>register_shutdown_function</function>.
+ Vous pouvez contourner ce problème en écrivant une fonction
+ d'encapsulation qui appelera la fonction <literal>old_function</literal>.
</para>
</warning>
</sect1>
@@ -266,10 +269,10 @@
<title>Variable functions</title>
<para>
PHP supporte le concept de fonctions variables. Cela signifie
- que si le nom d'une variable est entourée de
- parenthèses, PHP recherchera une fonction de même nom,
+ que si le nom d'une variable est suivi de parenthèses,
+ PHP recherchera une fonction de même nom,
et essaiera de l'exécuter. Cela peut servir, entre autre,
- lors de call back, de tables de fonctions...
+ lors pour faire des fonctions call-back, des tables de fonctions...
</para>
<para>
<example>
@@ -286,7 +289,7 @@
$func();
$func = 'bar';
$func( 'test' );
-?>
+?>
</programlisting>
</example>
</para>
Index: phpdoc/fr/language/oop.xml
diff -u phpdoc/fr/language/oop.xml:1.2 phpdoc/fr/language/oop.xml:1.3
--- phpdoc/fr/language/oop.xml:1.2 Wed Nov 8 01:50:56 2000
+++ phpdoc/fr/language/oop.xml Fri Jan 12 02:56:51 2001
@@ -1,174 +1,161 @@
<chapter id="oop">
<title>Classes et objets</title>
-
<sect1 id="keyword.class">
<title>Les classes : <literal>class</literal></title>
<para>
- Une classe est une collection de variables et de fonctions qui
- fonctionnent avec ces variables. Une classe est définie
+ Une classe est une collection de variables et de fonctions qui
+ fonctionnent avec ces variables. Une classe est définie
en utilisant la syntaxe suivante :
-
<informalexample>
<programlisting role="php">
<?php
class Cart {
var $items; // Eléments de notre panier
-
// Ajout de $num articles de type $artnr au panier
-
function add_item ($artnr, $num) {
$this->items[$artnr] += $num;
}
-
// Suppression de $num articles du type $artnr du panier
-
function remove_item ($artnr, $num) {
if ($this->items[$artnr] > $num) {
$this->items[$artnr] -= $num;
- return true;
+ return <literal>TRUE</literal>;
} else {
- return false;
- }
+ return <literal>FALSE</literal>;
+ }
}
}
-?>
+?>
</programlisting>
</informalexample>
</para>
-
<para>
- L'exemple ci-dessus définit la classe Cart qui est composée d'un
tableau
- associatif contenant les articles du panier et de deux fonctions, une pour
ajouter
- et une pour enlever des éléments au panier.
+ L'exemple ci-dessus définit la classe Cart qui est composée d'un
+ tableau associatif contenant les articles du panier et de deux fonctions,
+ une pour ajouter et une pour enlever des éléments au panier.
</para>
<note>
<simpara>
- En PHP 4, seuls les initialiseurs constants pour les variables
- <literal>var</literal> sont autorisés. Utilisez les constructeurs pour
- les initialisation variables.
+ En PHP 4, seuls les initialiseurs constants pour les variables
+ <literal>var</literal> sont autorisés. Utilisez les constructeurs pour
+ les initialisation variables.
</simpara>
</note>
<para>
- Les classes sont un type de variable. Pour créer
- une variable du type désiré, vous devez utiliser
- l'opérateur new.
+ Les classes forment un type de variable. Pour créer une variable
+ du type désiré, vous devez utiliser l'opérateur new.
</para>
-
<informalexample>
<programlisting role="php">
+<?php
$cart = new Cart;
$cart->add_item("10", 1);
+?>
</programlisting>
</informalexample>
<para>
L'instruction ci-dessus crée l'objet $cart de la class Cart.
- La fonction add_idem() est appelée afin d'ajouter l'article
+ La fonction add_idem() est appelée afin d'ajouter l'article
numéro 10 dans la panier.
</para>
- <para>
- Une classe peut être une extension d'une autre classe.
- Les classes "extended" ou "derived" héritent de toutes
+ <para>
+ Une classe peut être une extension d'une autre classe.
+ Les classes "extended" ou "derived" héritent de toutes
les variables et de toutes les fonctions de la classe père
plus toutes les définitions que vous rajoutez à cette
classe. Cela se fait avec le mot clef "extends".
L'héritage multiple n'est pas supporté.
</para>
-
<informalexample>
<programlisting role="php">
+<?php
class Named_Cart extends Cart {
var $owner;
-
function set_owner ($name) {
$this->owner = $name;
}
}
+?>
</programlisting>
</informalexample>
-
<para>
- L'exemple ci-desssus définit la classe Named_Cart qui
- possède les même variables que la classe Cart et
- la variable $owner en plus, ainsi que la fonction set_owner().
- Vous créez un panier nominatif de la même
- manière que précédemment, et vous pouvez alors
- affecter un nom au panier ou en connaître le nom. Vous pouvez de
- toutes les façons utiliser les même fonctions que sur un
+ L'exemple ci-desssus définit la classe Named_Cart qui
+ possède les même variables que la classe Cart et
+ la variable $owner en plus, ainsi que la fonction set_owner().
+ Vous créez un panier nominatif de la même
+ manière que précédemment, et vous pouvez alors
+ affecter un nom au panier ou en connaître le nom. Vous pouvez de
+ toutes les façons utiliser les même fonctions que sur un
panier classique.
</para>
-
<informalexample>
<programlisting role="php">
+<?php
$ncart = new Named_Cart; // Création d'un panier nominatif
$ncart->set_owner ("kris"); // Affectation du nom du panier
print $ncart->owner; // Affichage du nom du panier
$ncart->add_item ("10", 1); // (héritage des fonctions de la classe
père)
+?>
</programlisting>
</informalexample>
-
<para>
- Dans les fonctions d'une classe, la variable $this est
- égale à l'objet de la classe. Vous pouvez
- utilisez la forme "$this->quelquechose" pour accéder aux
+ Dans les fonctions d'une classe, la variable $this est
+ égale à l'objet de la classe. Vous pouvez
+ utilisez la forme "$this->quelquechose" pour accéder aux
fonctions ou aux variables de l'objet courant.
</para>
<para>
- Le constructeur est la fonction qui est appelée
- automatiquement par la classe lorsque vous créez
- une nouvelle instance d'une classe. La fonction constructeur a
+ Le constructeur est la fonction qui est appelée
+ automatiquement par la classe lorsque vous créez
+ une nouvelle instance d'une classe. La fonction constructeur a
le même nom que la classe.
</para>
-
<informalexample>
<programlisting role="php">
+<?php
class Auto_Cart extends Cart {
function Auto_Cart () {
$this->add_item ("10", 1);
}
}
+?>
</programlisting>
</informalexample>
-
<para>
- L'exemple ci-dessus définit la classe Auto_Cart qui
- hérite de la classe Cart et définit le construteur
- de la classe. Ce dernier initialise le panier avec 1 article de
- type numéro 10 dès que l'instruction "new" est
- appelée. La fonction constructeur peut prendre ou non,
- des paramètres optionnels, ce qui la rend
+ L'exemple ci-dessus définit la classe Auto_Cart qui
+ hérite de la classe Cart et définit le construteur
+ de la classe. Ce dernier initialise le panier avec 1 article de
+ type numéro 10 dès que l'instruction "new" est
+ appelée. La fonction constructeur peut prendre ou non,
+ des paramètres optionnels, ce qui la rend
beaucoup plus pratique.
</para>
-
<informalexample>
<programlisting role="php">
+<?php
class Constructor_Cart extends Cart {
function Constructor_Cart ($item = "10", $num = 1) {
$this->add_item ($item, $num);
}
}
-
// Place dans le caddie toujours la même chose...
-
$default_cart = new Constructor_Cart;
-
-// Place dans le caddie des objets différents, comme dans la
réalité
-
+// Place dans le caddie des objets différents, comme dans la
+// réalité
$different_cart = new Constructor_Cart ("20", 17);
+?>
</programlisting>
</informalexample>
-
<caution>
<simpara>
- Pour les classes qui utilisent l'héritage,
- le constructeur de la classe père n'est pas
- automatiquement appelé lorsque le constructeur de la classe
- dérivée est appelé.
- </simpara>
+ Pour les classes qui utilisent l'héritage,
+ le constructeur de la classe père n'est pas
+ automatiquement appelé lorsque le constructeur de la classe
+ dérivée est appelé.
+ </simpara>
</caution>
</sect1>
-
</chapter>
-
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
Index: phpdoc/fr/language/operators.xml
diff -u phpdoc/fr/language/operators.xml:1.5 phpdoc/fr/language/operators.xml:1.6
--- phpdoc/fr/language/operators.xml:1.5 Fri Nov 17 00:45:55 2000
+++ phpdoc/fr/language/operators.xml Fri Jan 12 02:56:51 2001
@@ -2,12 +2,11 @@
<title>Les opérateurs</title>
<simpara>
</simpara>
-
<sect1 id="language.operators.arithmetic">
<title>Les opérateurs arithmétiques</title>
<simpara>
- Vous rappelez vous des opérations élémentaires
- apprises à l'école ?
+ Vous rappelez vous des opérations élémentaires
+ apprises à l'école ?
</simpara>
<table>
<title>Opérations élémentaires</title>
@@ -48,70 +47,74 @@
</tbody>
</tgroup>
</table>
-
<simpara>
L'opérateur de division ("/") retourne une valeur entière
(le résultat d'une division entière) si les deux opérandes
- sont entiers (ou bien des chaînes converties en entiers.
+ sont entiers (ou bien des chaînes converties en entiers.
Si l'un des opérandes est un nombre à virgule flottante,
ou bien le résultat d'une opération qui retourne une valeur
non entière, un nombre à virgule flottante sera retourné.
</simpara>
</sect1>
-
<sect1 id="language.operators.assignment">
<title>Les opérateurs d'assignement</title>
<simpara>
- L'opérateurs d'assignement le plus simple est le signe "=".
- Le premier réflexe est de penser que ce signe veut dire
- "égal à". Ce n'est pas le cas. Il signifie que
- l'opérande de gauche se voit affecter la valeur de
+ L'opérateurs d'assignement le plus simple est le signe "=".
+ Le premier réflexe est de penser que ce signe veut dire
+ "égal à". Ce n'est pas le cas. Il signifie que
+ l'opérande de gauche se voit affecter la valeur de
l'expression qui est à droite du signe égal.
</simpara>
<para>
- La valeur d'une expression d'assignement est la valeur
- assignée. Par exemple, la valeur de l'expression
- '$a = 3' est la valeur 3. Cela permet de faire d'utiliser
- des astuces telles que :
+ La valeur d'une expression d'assignement est la valeur
+ assignée. Par exemple, la valeur de l'expression
+ '$a = 3' est la valeur 3. Cela permet de faire d'utiliser
+ des astuces telles que :
<informalexample>
- <programlisting>
- $a = ($b = 4) + 5; // $a est maintenant égal à 9, et $b vaut 4.
+ <programlisting role="php">
+<?php
+$a = ($b = 4) + 5; // $a est maintenant égal à 9, et $b vaut 4.
+?>
</programlisting>
</informalexample>
</para>
<para>
- En plus du simple opérateur d'assignement, il existe des
- "opérateurs combinés" pour tous les opérateurs
- arithmétiques et pour les opérateurs sur les
- chaînes de caractères. Cela permet d'utiliser
- la valeur d'une variable dans une expression et d'affecter le
- résultat de cette expression à cette variable.
- Par exemple:
+ En plus du simple opérateur d'assignement, il existe des
+ "opérateurs combinés" pour tous les opérateurs
+ arithmétiques et pour les opérateurs sur les
+ chaînes de caractères. Cela permet d'utiliser
+ la valeur d'une variable dans une expression et d'affecter le
+ résultat de cette expression à cette variable.
+ Par exemple:
<informalexample>
- <programlisting>
+ <programlisting role="php">
+<?php
$a = 3;
-$a += 5; // affecte la valeur 8 à la variable $a. (correspond à
l'instruction '$a = $a + 5');
+$a += 5;
+// affecte la valeur 8 à la variable $a.
+// correspond à l'instruction '$a = $a + 5');
$b = "Bonjour ";
-$b .= " tout le monde!"; // affecte la valeur "Bonjour tout le monde!" à la
variable $b (correspond à $b = $b." tout le monde!";
+$b .= " tout le monde!";
+// affecte la valeur "Bonjour tout le monde!" à
+la variable $b (correspond à $b = $b." tout le monde!";
+?>
</programlisting>
</informalexample>
</para>
-
<para>
- On peut noter que l'assignement copie le contenu de la variable originale
+ 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
de valeur d'une variable ne modifieront pas la valeur de l'autre. Cela peut
- se revéler important lors de la copie d'un grand tableau
- durant une boucle. PHP4 supporte aussi l'assignement par
- référence, en utilisant la syntaxe
- <computeroutput>$var = &$othervar;</computeroutput>, mais ce
- n'était pas possible en PHP3. 'L'assignement par
+ se revéler important lors de la copie d'un grand tableau
+ durant une boucle. PHP 4 supporte aussi l'assignement par
+ référence, en utilisant la syntaxe
+ <computeroutput>$var = &$othervar;</computeroutput>, mais ce
+ n'était pas possible en PHP 3. 'L'assignement par
référence' signifie que les deux variables contiennent les
- mêmes données, et que la modification de l'une affecte
+ mêmes données, et que la modification de l'une affecte
l'autre. D'un autre coté, la recopie est très rapide.
</para>
</sect1>
-
<sect1 id="language.operators.bitwise">
<title>Bitwise Operators</title>
<simpara>
@@ -141,7 +144,7 @@
<entry>$a | $b</entry>
<entry>OU (OR)</entry>
<entry>
- Les bits positionnés à 1 dans $a OU $b sont
+ Les bits positionnés à 1 dans $a OU $b sont
sont positionnés à 1.
</entry>
</row>
@@ -149,7 +152,7 @@
<entry>$a ^ $b</entry>
<entry>Xor</entry>
<entry>
- Les bits positionnés à 1 dans $a OU dans $b
+ Les bits positionnés à 1 dans $a OU dans $b
sont positionnés à 1.
</entry>
</row>
@@ -157,7 +160,7 @@
<entry>~ $a</entry>
<entry>NON (Not)</entry>
<entry>
- Les bits qui sont positionnés à 1 dans $a
+ Les bits qui sont positionnés à 1 dans $a
sont positionnés à 0, et vice versa.
</entry>
</row>
@@ -165,7 +168,7 @@
<entry>$a << $b</entry>
<entry>Décalage à gauche</entry>
<entry>
- Décale les bits de $a dans $b par la gauche
+ Décale les bits de $a dans $b par la gauche
(chaque décalage équivaut à une multiplication par 2).
</entry>
</row>
@@ -173,7 +176,7 @@
<entry>$a >> $b</entry>
<entry>Décalage à droite</entry>
<entry>
- Décalage des bits de $a dans $b par la droite
+ Décalage des bits de $a dans $b par la droite
(chaque décalage équivaut à une division par 2).
</entry>
</row>
@@ -181,11 +184,10 @@
</tgroup>
</table>
</sect1>
-
<sect1 id="language.operators.comparison">
<title>Opérateurs de comparaison</title>
<simpara>
- Les opérateurs de comparaison, comme leur nom l'indique,
+ Les opérateurs de comparaison, comme leur nom l'indique,
vous permettent de comparer deux valeurs.
</simpara>
<table>
@@ -207,7 +209,10 @@
<row>
<entry>$a === $b</entry>
<entry>Identique</entry>
- <entry>Vrai si $a est égal à $b et qu'ils sont de même
type (PHP4 seulement).</entry>
+ <entry>
+ Vrai si $a est égal à $b et qu'ils sont de même type
+ (PHP 4 seulement).
+ </entry>
</row>
<row>
<entry>$a != $b</entry>
@@ -238,32 +243,30 @@
</tgroup>
</table>
<para>
- Un autre opérateur conditionnel est l'opérateur
- ternaire (":?"), qui fonctionne comme en langage C.
-
+ Un autre opérateur conditionnel est l'opérateur
+ ternaire (":?"), qui fonctionne comme en langage C.
<informalexample>
- <programlisting>
+ <programlisting role="php">
+<?php
(expr1) ? (expr2) : (expr3);
+?>
</programlisting>
- </informalexample>
- Cette expression renvoie la valeur de l'expression
- <replaceable>expr2</replaceable> si l'expression
- <replaceable>expr1</replaceable> est vraie, et l'expression
- <replaceable>expr3</replaceable> si l'expression
+ </informalexample>
+ Cette expression renvoie la valeur de l'expression
+ <replaceable>expr2</replaceable> si l'expression
+ <replaceable>expr1</replaceable> est vraie, et l'expression
+ <replaceable>expr3</replaceable> si l'expression
<replaceable>expr1</replaceable> est fausse.
</para>
</sect1>
-
<sect1 id="language.operators.errorcontrol">
<title>Opérateur de contrôle d'erreur</title>
-
<simpara>
PHP supporte un opératuer de contrôle d'erreur : c'est @. Lorsque cet
opérateur est ajouté en préfixe d'une expression PHP, les
messages
d'erreur qui peuvent être générés par cette expression
seront
ignorés.
</simpara>
-
<simpara>
Si l'option <link linkend="ini.track-errors">track_errors</link>
est activée, les messages d'erreurs générés une
expression seront
@@ -286,23 +289,21 @@
Voir aussi <function>error_reporting</function>.
</simpara>
</sect1>
-
-
<sect1 id="language.operators.execution">
<title>Opérateur d'exécutions</title>
-
<para>
PHP supporte un opérateur d'exécution : guillemets obliques
("``").
Notez bien la différence avec les guillemets simples (sur la touche
- 4), et ceux-ci (sur la touche de la livre anglaise). PHP essaiera
+ 4), et ceux-ci (sur la touche de la livre anglaise). PHP essaiera
d'exécuter le contenu de ces guillemets obliques comme une commande
shell. Le résultat sera retourné (i.e. : il ne sera pas
simplement
envoyé à la sortie standard, il peut être assigné
à une variable).
-
<informalexample>
<programlisting role="php">
+<?php
$output = `ls -al`;
echo "<pre>$output</pre>";
+?>
</programlisting>
</informalexample>
</para>
@@ -313,15 +314,12 @@
<function>escapeshellcmd</function>.
</para>
</sect1>
-
<sect1 id="language.operators.increment">
<title>Opérateurs d'incrementation/Décrementation</title>
-
<para>
PHP supporte les opérateurs de pré et post incrémentation
et
décrémentation, comme en C.
</para>
-
<table>
<title>Opérateurs d'incrementation/Décrementation</title>
<tgroup cols="3">
@@ -356,39 +354,32 @@
</tbody>
</tgroup>
</table>
-
<para>
- Voici un exempla simple
+ Voici un exempla simple
<informalexample>
- <programlisting>
+ <programlisting role="php">
<?php
echo "<h3>Post-incrémentation</h3>";
$a = 5;
echo "Devrait valoir 5: " . $a++ . "<br>\n";
echo "Devrait valoir 6: " . $a . "<br>\n";
-
echo "<h3>Pré-incrémentation</h3>";
$a = 5;
echo "Devrait valoir 6: " . ++$a . "<br>\n";
echo "Devrait valoir 6: " . $a . "<br>\n";
-
echo "<h3>Post-décrémentation</h3>";
$a = 5;
echo "Devrait valoir 5: " . $a-- . "<br>\n";
echo "Devrait valoir 4: " . $a . "<br>\n";
-
echo "<h3>Pré-décrementation</h3>";
$a = 5;
echo "Devrait valoir 4: " . --$a . "<br>\n";
echo "Devrait valoir 4: " . $a . "<br>\n";
-?>
+?>
</programlisting>
</informalexample>
</para>
-
</sect1>
-
-
<sect1 id="language.operators.logical">
<title>Les opérateurs logiques</title>
<table>
@@ -414,7 +405,7 @@
</row>
<row>
<entry>$a xor $b</entry>
- <entry>XOR(Or)</entry>
+ <entry>XOR (Xor)</entry>
<entry>Vrai si $a OU $b est vrai, mais pas les deux en même
temps.</entry>
</row>
<row>
@@ -437,26 +428,25 @@
</table>
<simpara>
La raison pour laquelle il existe deux types de "ET" et de "OU"
- est qu'ils ont des priorités différentes. Voir le
- paragraphe
+ est qu'ils ont des priorités différentes. Voir le
+ paragraphe
<link linkend="language.operators.precedence">précédence
d'opérateurs</link>.
</simpara>
</sect1>
-
<sect1 id="language.operators.precedence">
<title>La précédence des opérateurs</title>
<para>
- La priorité des opérateurs spécifie
- l'ordre dans lequel les valeurs doivent être analysées.
- Par exemple, dans l'expression 1 + 5 * 3, le résultat est
- 16 et non 18, car la multiplication ("*") à une
- priorité supérieure par rapport à
+ La priorité des opérateurs spécifie
+ l'ordre dans lequel les valeurs doivent être analysées.
+ Par exemple, dans l'expression 1 + 5 * 3, le résultat est
+ 16 et non 18, car la multiplication ("*") à une
+ priorité supérieure par rapport à
à l'addition ("+").
</para>
<para>
- Le tableau suivant dresse une liste de la priorité des
- différents opérateurs dans un ordre croissant de
- priorité.
+ Le tableau suivant dresse une liste de la priorité des
+ différents opérateurs dans un ordre croissant de
+ priorité.
<table>
<title>Précédence des opérateurs</title>
<tgroup cols="2">
@@ -489,7 +479,7 @@
</row>
<row>
<entry>gauche</entry>
- <entry>= += -= *= /= .= %= &= |= ^= ~= <<= >>=</entry>
+ <entry>= += -= *= /= .= %= &= |= ^= ~= <<=>>=</entry>
</row>
<row>
<entry>gauche</entry>
@@ -549,33 +539,34 @@
</row>
</tbody>
</tgroup>
- </table></para></sect1>
-
+ </table>
+ </para>
+ </sect1>
<sect1 id="language.operators.string">
<title>Opérateurs de chaînes</title>
<simpara>
- Il y a deux opérateurs de chaînes. Le premier
- est l'opérateur de concaténation ('.'), qui
+ Il y a deux opérateurs de chaînes. Le premier
+ est l'opérateur de concaténation ('.'), qui
retourne la concaténation de ses deux arguments.
- Le second est l'opérateur d'assignement
- concaténant ('.='). Reportez vous à
- <link linkend="language.operators.assignment">Opérateurs
d'assignements</link>
+ Le second est l'opérateur d'assignement
+ concaténant ('.='). Reportez vous à
+ <link linkend="language.operators.assignment">Opérateurs
+d'assignements</link>
pour plus de détails.
</simpara>
<para>
<informalexample>
- <programlisting>
+ <programlisting role="php">
+<?php
$a = "Bonjour ";
$b = $a . "Monde!"; // $b contient "Bonjour Monde!"
-
$a = "Bonjour ";
$a = $a . "Monde!"; // $a contient "Bonjour Monde!"
+?>
</programlisting>
</informalexample>
</para>
</sect1>
</chapter>
-
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
Index: phpdoc/fr/language/references.xml
diff -u phpdoc/fr/language/references.xml:1.3 phpdoc/fr/language/references.xml:1.4
--- phpdoc/fr/language/references.xml:1.3 Wed Dec 13 05:29:57 2000
+++ phpdoc/fr/language/references.xml Fri Jan 12 02:56:51 2001
@@ -21,10 +21,12 @@
<para>
Les références vous permettent de faire pointer
deux variables sur le même contenu. Par exemple, lorsque
- vous faites :
+ vous faîtes :
<informalexample>
<programlisting role="php">
+<?php
$a =& $b
+?>
</programlisting>
</informalexample>
cela signifie que <varname>$a</varname> et <varname>$b</varname>
@@ -42,19 +44,21 @@
(PHP 4.0.4 et plus récent):
<informalexample>
<programlisting role="php">
+<?php
$bar =& new fooclass();
$foo =& find_var ($bar);
- </programlisting>
+?>
+ </programlisting>
</informalexample>
</para>
<note>
<para>
- A moins d'utiliser la syntaxe ci-dessus, le résultat de
- <literal>$bar = new fooclass()</literal> ne sera pas la même variable
- que <literal>$this</literal> dans le constructeur, ce qui signifie
- que si vous avez utilisé la référence
<literal>$this</literal> dans le
- constructeur, vous devez assigner la référence, ou bien obtenir
deux
- objets différents.
+ A moins d'utiliser la syntaxe ci-dessus, le résultat de
+ <literal>$bar = new fooclass()</literal> ne sera pas la même variable
+ que <literal>$this</literal> dans le constructeur, ce qui signifie
+ que si vous avez utilisé la référence
+<literal>$this</literal> dans le
+ constructeur, vous devez assigner la référence, ou bien obtenir
+deux
+ objets différents.
</para>
</note>
<para>
@@ -64,11 +68,13 @@
le contenu des variables de fonction. Exemple :
<informalexample>
<programlisting role="php">
+<?php
function foo (&$var) {
$var++;
}
$a=5;
foo ($a);
+?>
</programlisting>
</informalexample>
<varname>$a</varname> vaut 6. Cela provient du fait que dans la fonction
@@ -91,10 +97,12 @@
de à quoi on peut s'attendre :
<informalexample>
<programlisting role="php">
+<?php
function foo (&$var) {
$var =& $GLOBALS["baz"];
}
foo($bar);
+?>
</programlisting>
</informalexample>
</para>
@@ -116,12 +124,14 @@
fonction modifie ses arguments. La syntaxe est la suivante :
<informalexample>
<programlisting role="php">
+<?php
function foo (&$var) {
$var++;
}
$a=5;
foo ($a);
// $a vaut 6 maintenant
+?>
</programlisting>
</informalexample>
Notez qu'il n'y a pas de signe de référence dans l'appel de la
fonction,
@@ -215,13 +225,15 @@
<title>Détruire une références</title>
<para>
Lorsque vous détruiser une référence, vous ne
- faites que casser le lien entre le nom de la variable et son contenu.
+ faîtes que casser le lien entre le nom de la variable et son contenu.
Cela ne signifie pas que le contenu est détruit. Par exemple,
<informalexample>
<programlisting role="php">
+<?php
$a = 1;
$b =& $a;
unset ($a);
+?>
</programlisting>
</informalexample>
Cet exemple ne détruira pas <varname>$b</varname>, mais juste
@@ -250,7 +262,9 @@
globale. Ce qui signifie que
<informalexample>
<programlisting role="php">
+<?php
$var =& $GLOBALS["var"];
+?>
</programlisting>
</informalexample>
</para>
Index: phpdoc/fr/language/types.xml
diff -u phpdoc/fr/language/types.xml:1.5 phpdoc/fr/language/types.xml:1.6
--- phpdoc/fr/language/types.xml:1.5 Wed Dec 20 01:50:12 2000
+++ phpdoc/fr/language/types.xml Fri Jan 12 02:56:51 2001
@@ -56,10 +56,12 @@
la manière suivante :
<informalexample>
<programlisting role="php">
+<?php
$a = 1234; # nombre entier en base 10
$a = -123; # nombre entier négatif
$a = 0123; # nombre entier en base 8, octale (équivalent à 83 en base
10)
$a = 0x12; # nombre entier en base 16, hexadécimale (équivalent
à 18 en base 10)
+?>
</programlisting>
</informalexample>
</para>
@@ -71,8 +73,10 @@
spécifiés en utilisant la syntaxe suivante:
<informalexample>
<programlisting role="php">
+<?php
$a = 1.234;
$a = 1.2e3;
+?>
</programlisting>
</informalexample>
</para>
@@ -90,15 +94,16 @@
<para>
Tout ceci est lié au fait qu'il est impossible d'exprimer
certaines fractions en un nombre fini de chiffres. Par exemple
- <literal>1/3</literal> s'écrira <literal>0.3333333. . .</literal>
+ <literal>1/3</literal> s'écrira <literal>0.3333333...</literal>
en mode décimal.
</para>
<para>
- Ne faites donc jamais confiance aux nombres à virgule jusqu'à
- leur dernière décimale, et ne comparer jamais ces nombres
- avec l'opérateur d'égalité. Si vous avez besoin d'une
- précision particulière, reportez vous au traitement
- des <link linkend="ref.bc">nombres de grande taille</link>.
+ Ne faîtes donc jamais confiance aux nombres à virgule
+ jusqu'à leur dernière décimale, et ne comparer
+ jamais ces nombres avec l'opérateur d'égalité.
+ Si vous avez besoin d'une précision particulière,
+ reportez vous au traitement des nombres de grande taille avec les
+ librairies <link linkend="ref.bc">BC</link> ou <link
+linkend="ref.gmp">GMP</link>.
</para>
</warning>
</sect1>
@@ -165,7 +170,8 @@
</row>
</tbody>
</tgroup>
- </table></para>
+ </table>
+ </para>
<para>
Vous pouvez utiliser le caractère d'échappement
antislash sur n'importe quel autre caractère, mais cela
@@ -195,14 +201,14 @@
</para>
<para>
La syntaxe Here doc se comporte exactement comme une chaîne à
- guillements doubles, sans les guillemets doubles. Cela signifie
+ guillemets doubles, sans les guillemets doubles. Cela signifie
que vous n'avez pas à échapper les guillemets (simples ou doubles)
dans cette syntaxe. Les variables sont remplacées par leur valeur, et
le même soin doit leur être aporté que dans les chaînes
à guillemets
doubles.
<example>
- <title>Exemple de chaîne doc</title>
- <programlisting>
+ <title>Exemple de chaîne Here Doc</title>
+ <programlisting role="php">
<?php
$str = <<<EOD
Exemple de chaîne
@@ -226,7 +232,7 @@
Maintenant, j'affiche un {$foo->bar[1]}.
Ceci se traduit par un 'A' majuscule: \x41
EOT;
-?>
+?>
</programlisting>
</example>
</para>
@@ -244,7 +250,7 @@
</para>
<para>
<example>
- <title>Quelques exemples de chaîes</title>
+ <title>Quelques exemples de chaînes</title>
<programlisting role="php">
<?php
/* Assignation d'une chaîne */
@@ -253,12 +259,12 @@
$str = $str . " avec une extension";
/* Une autre méthode de concaténation, y compris une nouvelle ligne */
$str .= " et terminée par une nouvelle ligne.\n";
-/* Cette chaî se terminera par '<p>Nombre: 9</p>' */
+/* Cette chaî se terminera par '<B>Nombre: 9</B>' */
$nombre = 9;
-$str = "<p>Nombre: $nombre</p>";
-/* Cette ci sera '<p>Nombre: $num</p>' */
+$str = "<B>Nombre: $nombre</B>";
+/* Cette ci sera '<B>Nombre: $num</B>' */
$num = 9;
-$str = '<p>Nombre: $num</p>';
+$str = '<B>Nombre: $num</B>';
/* Lire le premier caractère d'une chaîne */
$str = 'Ceci est un test.';
$first = $str[0];
@@ -296,6 +302,7 @@
</simpara>
<informalexample>
<programlisting role="php">
+<?php
$foo = 1 + "10.5"; // $foo est du type double (11.5)
$foo = 1 + "-1.3e3"; // $foo est du type double (-1299)
$foo = 1 + "bob-1.3e3"; // $foo est du type integer (1)
@@ -304,6 +311,7 @@
$foo = 1 + "10 Little Piggies"; // $foo est du type integer (11)
$foo = "10.0 pigs " + 1; // $foo est du type integer (11)
$foo = "10.0 pigs " + 1.0; // $foo est du type double (11)
+?>
</programlisting>
</informalexample>
<simpara>
@@ -311,12 +319,14 @@
pages de man à propos de la fonction strtod(3).
</simpara>
<para>
- If you would like to test any of the examples in this section,
- you can cut and paste the examples and insert the following line
- to see for yourself what's going on:
+ Si vous voulez testez l'un des exemples de cette section,
+ vous pouvez faire un copier/coller et l'insérer dans un script
+ pour voir comment il se comporte.
<informalexample>
<programlisting role="php">
+<?php
echo "\$foo==$foo; type is " . gettype( $foo ) . "<br>\n";
+?>
</programlisting>
</informalexample>
</para>
@@ -337,9 +347,11 @@
en affectant explicitement chacune des valeurs.
<informalexample>
<programlisting role="php">
+<?php
$a[0] = "abc";
$a[1] = "def";
$b["foo"] = 13;
+?>
</programlisting>
</informalexample>
</para>
@@ -348,10 +360,13 @@
simplement les valeurs à ce tableau.
<informalexample>
<programlisting role="php">
-$a[] = "hello"; // $a[2] == "hello"
-$a[] = "world"; // $a[3] == "world"
+<?php
+$a[] = "Bonjour"; // $a[2] == "Bonjour";
+$a[] = "Monde"; // $a[3] == "Monde";
+?>
</programlisting>
- </informalexample></para>
+ </informalexample>
+ </para>
<para>
Un tableau peut être trié en utilisant les fonctions
<function>asort</function>,
@@ -379,22 +394,27 @@
la fin:
<informalexample>
<programlisting role="php">
+<?php
$a[1] = $f; # tableau à une dimension
$a["foo"] = $f;
$a[1][0] = $f; # tableau à deux dimensions
$a["foo"][2] = $f; # vous pouvez mélanger les indices associatifs
et numériques
$a[3]["bar"] = $f; # vous pouvez mélanger les indices associatifs
et numériques
$a["foo"][4]["bar"][0] = $f; # tableau à quatre dimensions
+?>
</programlisting>
- </informalexample></para>
+ </informalexample>
+ </para>
<para>
En PHP 3 il n'est pas possible de référencer un tableau
à l'intérieur d'une chaîne. Par exemple, ceci ne
fonctionne pas :
<informalexample>
<programlisting role="php">
+<?php
$a[3]['bar'] = 'Bob';
echo "Cela ne marche pas : $a[3][bar]";
+?>
</programlisting>
</informalexample>
En PHP 3, l'exemple ci dessu va afficher :
@@ -403,8 +423,10 @@
peut être utilisé pour corriger cela :
<informalexample>
<programlisting role="php">
+<?php
$a[3]['bar'] = 'Bob';
echo "Cela ne marche pas : " . $a[3][bar];
+?>
</programlisting>
</informalexample>
</para>
@@ -413,8 +435,10 @@
en entourant le tableau par des accolades :
<informalexample>
<programlisting role="php">
+<?php
$a[3]['bar'] = 'Bob';
echo "Cela marche : {$a[3][bar]}";
+?>
</programlisting>
</informalexample>
</para>
@@ -426,6 +450,7 @@
montre comment remplir un tableau à une dimension:
<informalexample>
<programlisting role="php">
+<?php
# Exemple 1:
$a["couleur"] = "rouge";
$a["saveur"] = "sucrée";
@@ -440,6 +465,7 @@
"nom" => "pomme",
3 => 4
);
+?>
</programlisting>
</informalexample>
</para>
@@ -449,7 +475,7 @@
plusieurs dimensions :
<informalexample>
<programlisting role="php">
-<?
+<?php
$a = array(
"pomme" => array(
"couleur" => "rouge",
@@ -468,7 +494,7 @@
)
);
echo $a["pomme"]["saveur"]; # va afficher "sucrée"
-?>
+?>
</programlisting>
</informalexample>
</para>
@@ -483,6 +509,7 @@
afin de créer linstance de l'objet.
<informalexample>
<programlisting role="php">
+<?php
class foo {
function faire_foo () {
echo "Faisant foo.";
@@ -490,6 +517,7 @@
}
$bar = new foo;
$bar->do_foo();
+?>
</programlisting>
</informalexample>
</para>
@@ -518,12 +546,14 @@
sont évaluées.
<informalexample>
<programlisting role="php">
+<?php
$foo = "0"; // $foo est une chaîne de caractères (ASCII 48)
$foo++; // $foo est la chaîne de caractères "1" (ASCII 49)
$foo += 1; // $foo est maintenant du type entier (2)
$foo = $foo + 1.3; // $foo est maintenant du type double (3.3)
-$foo = 5 + "10 Little Piggies"; // $foo est du type entier (15)
-$foo = 5 + "10 Small Pigs"; // $foo est du type entier (15)
+$foo = 5 + "10 Petits cochons"; // $foo est du type entier (15)
+$foo = 5 + "10 cochonnets"; // $foo est du type entier (15)
+?>
</programlisting>
</informalexample>
</para>
@@ -532,7 +562,7 @@
voulez forcer une variable a être évaluée
avec un certain type, reportez vous au paragraphe Conversion de
type ci-dessous. Si vous voulez changer le type d'une variable,
- intéressez vous à aux fonctions de
+ intéressez vous à aux fonctions de
<link linkend="language.types.string.conversion">conversion de
chaînes</link>.
</simpara>
<simpara>
@@ -547,7 +577,9 @@
un copier/coller, et d'insèrer les lignes dans un script PHP.
<informalexample>
<programlisting role="php">
+<?php
echo "\$foo==$foo; le type est " . gettype( $foo ) . "<br>\n";
+?>
</programlisting>
</informalexample>
</para>
@@ -557,8 +589,10 @@
indéfinie.
<informalexample>
<programlisting role="php">
+<?php
$a = 1; // $a est un entier
$a[0] = "f"; // $a devient un tableau, et $a[0] contient "f"
+?>
</programlisting>
</informalexample>
</para>
@@ -568,8 +602,10 @@
est 'f', considérez l'exemple suivant :
<informalexample>
<programlisting role="php">
+<?php
$a = "1"; // $a est une chaîne
$a[0] = "f"; // Qu'est ce qu'une position dans une chaîne ? que se passe t il?
+?>
</programlisting>
</informalexample>
</para>
@@ -597,10 +633,13 @@
à transtyper ("cast").
<informalexample>
<programlisting role="php">
-$foo = 10; // $foo is an integer
+<?php
+$foo = 10; // $foo est un entier
$bar = (double) $foo; // $bar est un double
+?>
</programlisting>
- </informalexample></para>
+ </informalexample>
+ </para>
<para>
Les conversions autorisées sont:
<itemizedlist>
@@ -627,8 +666,10 @@
parenthèses, donc les lignes suivantes sont équivalentes:
<informalexample>
<programlisting role="php">
+<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
+?>
</programlisting>
</informalexample>
</para>
@@ -641,9 +682,11 @@
élément du tableau.
<informalexample>
<programlisting role="php">
+<?php
$var = 'ciao';
$arr = (array) $var;
echo $arr[0]; // affiche 'ciao'
+?>
</programlisting>
</informalexample>
</para>
@@ -653,9 +696,11 @@
l'objet. L'attribut s'appellera 'scalar':
<informalexample>
<programlisting role="php">
+<?php
$var = 'ciao';
$obj = (object) $var;
echo $obj->scalar; // affiche 'ciao'
+?>
</programlisting>
</informalexample>
</para>
Index: phpdoc/fr/language/variables.xml
diff -u phpdoc/fr/language/variables.xml:1.8 phpdoc/fr/language/variables.xml:1.9
--- phpdoc/fr/language/variables.xml:1.8 Mon Nov 20 16:51:06 2000
+++ phpdoc/fr/language/variables.xml Fri Jan 12 02:56:51 2001
@@ -1,70 +1,65 @@
<chapter id="language.variables">
<title>Les variables</title>
-
<sect1 id="language.variables.basics">
<title>Essentiel</title>
-
<simpara>
- En PHP, les variables sont représentées par un signe
+ En PHP, les variables sont représentées par un signe
dollar "$" suivi du nom de la variable. Le nom est sensible à
la casse (ie : $x != $X).
</simpara>
-
<para>
Les noms de variables suivent les mêmes règles de nommage que
les autres entitées PHP. Un nom de variable valide doit commencer par
une lettre ou un souligné (_), suivi de lettres, chiffres ou
soulignés.
- Exprimé sous forme d'expressions régulière, cela donne :
+ Exprimé sous forme d'expressions régulière, cela donne :
'[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
</para>
-
<note>
<simpara>
Dans nos propos, une lettre est a-z, A-Z, et les caractères ASCII
de 127 à 255 (0x7f-0xff).
</simpara>
</note>
-
<para>
<informalexample>
- <programlisting role="php">
+ <programlisting role="php">
+<?php
$var = "Jean";
$Var = "Paul";
echo "$var, $Var"; // affiche "Jean, Paul"
-
$4site = 'pas encore'; // invalide : commence par un nombre
$_4site = 'pas encore'; // valide : commence par un souligné
-$täyte = 'mansikka'; // valide : 'ä' est ASCII 228.
+$t”yte = 'mansikka'; // valide : '”' est ASCII 228.
+?>
</programlisting>
</informalexample>
</para>
<para>
En PHP3, les variables sont toujours assignées par valeur.
C'est à dire, lorsque vous assignez une expression à
- une variable, la valeur de l'expression est recopiée dans
- la variable. Cela signifie, par exemple, qu'après avoir
- assigné la valeur d'une variable à une autre,
+ une variable, la valeur de l'expression est recopiée dans
+ la variable. Cela signifie, par exemple, qu'après avoir
+ assigné la valeur d'une variable à une autre,
modifier une variable n'aura pas d'effet sur l'autre. Pour plus
- de détails sur ce genre d'assignement, reportez vous à
+ de détails sur ce genre d'assignement, reportez vous à
<link linkend="language.expressions">Expressions</link>.
</para>
<para>
- PHP4 permet aussi d'assigner les valeurs aux variables
- <emphasis>par référence</emphasis>. Cela
+ PHP 4.0 permet aussi d'assigner les valeurs aux variables
+ <emphasis>par référence</emphasis>. Cela
signifie que la nouvelle variable ne fait que référencer
- (en d'autres terme, "devient un alias de", ou encore "pointe sur") la
+ (en d'autres terme, "devient un alias de", ou encore "pointe sur") la
variable originale. Les modifications de la nouvelle variable
- affecteront l'ancienne, et vice versa. Cela signifie aussi
+ affecteront l'ancienne, et vice versa. Cela signifie aussi
qu'aucune copie n'est faite : l'assignement est donc beaucoup
- plus rapide. Cela se fera notamment sentir dans des boucles,
+ plus rapide. Cela se fera notamment sentir dans des boucles,
ou lors d'assignement de grands objets (tableaux).
</para>
<para>
Pour assigner par référence, ajoutze simplement
- un & (ET commercial) au début de la variable qui
+ un & (ET commercial) au début de la variable qui
est assignée (la variable source). Dans l'exemple suivant,
- 'Mon nom est Pierre' s'affichera deux fois :
-
+ 'Mon nom est Pierre' s'affichera deux fois :
<informalexample>
<programlisting role="php">
<?php
@@ -77,7 +72,6 @@
</programlisting>
</informalexample>
</para>
-
<para>
Une chose importante à noter est que seules, les variables
nommées peuvent être assignées par référence.
@@ -87,101 +81,89 @@
$foo = 25;
$bar = &$foo; // Assignement valide .
$bar = &(24 * 7); // Assignement Invalide : référence une
expression sans nom
-
function test() {
return 25;
}
-
$bar = &test(); // Invalide.
?>
</programlisting>
</informalexample>
</para>
-
</sect1>
-
<sect1 id="language.variables.predefined">
<title>Variables prédéfinies</title>
-
<simpara>
- PHP fourni un grand nombre de variables prédéfinies.
- Cependant, beaucoup de ces variables ne peuvent pas être
+ PHP fourni un grand nombre de variables prédéfinies.
+ Cependant, beaucoup de ces variables ne peuvent pas être
présentées ici, car elles dépendent du serveur
- sur lequel elles tournent, de la version du serveur, et de la
- configuration du serveur, ou encore d'autres facteurs.. Certaines
- de ces variables ne seront pas accessibles lorsque PHP fonctionne
- en exécutable.
+ sur lequel elles tournent, de la version du serveur, et de la
+ configuration du serveur, ou encore d'autres facteurs.. Certaines
+ de ces variables ne seront pas accessibles lorsque PHP fonctionne
+ en exécutable.
</simpara>
<simpara>
- Malgré ces données, voici une liste de variables
- prédéfinies, qui seront accessibles avec une
- installation ad hoc de PHP3, fonctionnant en module, sous
+ Malgré ces données, voici une liste de variables
+ prédéfinies, qui seront accessibles avec une
+ installation ad hoc de PHP3, fonctionnant en module, sous
<ulink url="&url.apache;">Apache</ulink> 1.3.6.
</simpara>
<simpara>
- Pour la liste complète des variables prédéfinies
- (et d'autres informations pratiques) reportez vous (et usez) de
+ Pour la liste complète des variables prédéfinies
+ (et d'autres informations pratiques) reportez vous (et usez) de
<function>phpinfo</function>.
</simpara>
-
<note>
<simpara>
Cette liste n'est pas exhaustive et ne le sera pas. C'est simplement un
- aperçu des variables prédéfinies qui
+ aperçu des variables prédéfinies qui
peuvent être accessibles dans les scripts.
</simpara>
</note>
-
<sect2 id="language.variables.predefined.apache">
<title>Variables Apache</title>
-
<simpara>
- Ces variables sont créées par le serveur
- <ulink url="&url.apache;">Apache</ulink>. Si vous utilisez un autre
+ Ces variables sont créées par le serveur
+ <ulink url="&url.apache;">Apache</ulink>. Si vous utilisez un autre
serveur web, il n'est pas sur que celui ci vous fournira
- les mêmes variables. Il peut ne pas les fournir, en
- fournir d'autres. Cependant, un bon nombre de ces variables
- font partie de l'interface <ulink url="&url.cgispec;">CGI 1.1</ulink>,
+ les mêmes variables. Il peut ne pas les fournir, en
+ fournir d'autres. Cependant, un bon nombre de ces variables
+ font partie de l'interface <ulink url="&url.cgispec;">CGI 1.1</ulink>,
et on peut s'attendre à les retrouver.
</simpara>
<simpara>
Notez que peu d'entre elles seront accessible lorsque PHP est appelé
en ligne de commande, (et elles n'auront alors peut être pas de sens)
</simpara>
-
<para>
<variablelist>
<varlistentry>
<term>GATEWAY_INTERFACE</term>
<listitem>
<simpara>
- Numéro de révision de l'interface CGI du serveur :
+ Numéro de révision de l'interface CGI du serveur :
i.e. 'CGI/1.1'.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>SERVER_NAME</term>
<listitem>
<simpara>
- Le nom du serveur hôte qui éxécute le script suivant.
- Si le script est exécuté sur un hôte virtuel, ce sera
+ Le nom du serveur hôte qui éxécute le script suivant.
+ Si le script est exécuté sur un hôte virtuel, ce sera
la valeur définie pour cet hôte virtuel.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>SERVER_SOFTWARE</term>
<listitem>
<simpara>
- Chaîne d'identification du serveur, qui est données dans
+ Chaîne d'identification du serveur, qui est données dans
les entêtes lors de la réponse aux requêtes.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>SERVER_PROTOCOL</term>
<listitem>
@@ -190,7 +172,6 @@
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>REQUEST_METHOD</term>
<listitem>
@@ -200,17 +181,15 @@
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>QUERY_STRING</term>
<listitem>
<simpara>
- La chaîne de requête, si elle existe, qui est
+ La chaîne de requête, si elle existe, qui est
utilisée pour accéder à la page.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>DOCUMENT_ROOT</term>
<listitem>
@@ -220,95 +199,86 @@
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_ACCEPT</term>
<listitem>
<simpara>
- Contenu de l'entête <literal>Accept:</literal> de la
+ Contenu de l'entête <literal>Accept:</literal> de la
requête courant, si il y en a une.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_ACCEPT_CHARSET</term>
<listitem>
<simpara>
- Contenu de l'entête <literal>Accept-Charset:</literal>
- de la requête courante, si il existe. Par exemple :
+ Contenu de l'entête <literal>Accept-Charset:</literal>
+ de la requête courante, si il existe. Par exemple :
'iso-8859-1,*,utf-8'.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_ENCODING</term>
<listitem>
<simpara>
- Contenu de l'entête <literal>Accept-Encoding:</literal>
+ Contenu de l'entête <literal>Accept-Encoding:</literal>
de la requête courante, si elle existe. Par exemple : 'gzip'.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_ACCEPT_LANGUAGE</term>
<listitem>
<simpara>
- Contenu de l'entête <literal>Accept-Language:</literal> de
+ Contenu de l'entête <literal>Accept-Language:</literal> de
la requête courante, si elle existe. Par exemple : 'en'.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_CONNECTION</term>
<listitem>
<simpara>
- Contenu de l'entête <literal>Connection:</literal> de la
+ Contenu de l'entête <literal>Connection:</literal> de la
requête courante, si elle existe. Par exemple : 'Keep-Alive'.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_HOST</term>
<listitem>
- <simpara>
- Contenu de l'entête <literal>Host:</literal> de la
- requête courante, si elle existe.
+ <simpara>
+ Contenu de l'entête <literal>Host:</literal> de la
+ requête courante, si elle existe.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_REFERER</term>
<listitem>
<simpara>
- L'adresse de la page (si elle existe) qui a conduit le
- client à la page courante. Cette valeur est
+ L'adresse de la page (si elle existe) qui a conduit le
+ client à la page courante. Cette valeur est
affectée par le client, et tous les clients ne le font pas.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_USER_AGENT</term>
<listitem>
<simpara>
- Contenu de l'entête <literal>User_Agent:</literal> de
- la requête courante, si elle existe. C'est une chaîne
+ Contenu de l'entête <literal>User_Agent:</literal> de
+ la requête courante, si elle existe. C'est une chaîne
qui décrit le client HTML utilisé pour voir
- la page courante. Par exemple :
- <computeroutput>Mozilla/4.5 [en] (X11; U; Linux 2.2.9
i586)</computeroutput>.
- Entre autres choses, vous pouvez utiliser cette valeur avec
- <function>get_browser</function> pour optimiser votre page
+ la page courante. Par exemple :
+ <computeroutput>Mozilla/4.5 [en] (X11; U; Linux 2.2.9
+i586)</computeroutput>.
+ Entre autres choses, vous pouvez utiliser cette valeur avec
+ <function>get_browser</function> pour optimiser votre page
en fonction des capacité du client.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>REMOTE_ADDR</term>
<listitem>
@@ -317,17 +287,15 @@
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>REMOTE_PORT</term>
<listitem>
<simpara>
- Le port utilisé par la machine cliente pour communiquer
+ Le port utilisé par la machine cliente pour communiquer
avec le serveur web.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>SCRIPT_FILENAME</term>
<listitem>
@@ -336,64 +304,58 @@
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>SERVER_ADMIN</term>
<listitem>
<simpara>
- La valeur donné à la directive SERVER_ADMIN
- (pour Apache), dans le fichier de configuration. Si le script
- est exécuté par un hôte virtuel, cela sera la
+ La valeur donné à la directive SERVER_ADMIN
+ (pour Apache), dans le fichier de configuration. Si le script
+ est exécuté par un hôte virtuel, cela sera la
valeur définie par l'hôte virtuel.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>SERVER_PORT</term>
<listitem>
<simpara>
- Le port de la machine serveur utilisé pour les
- communications. Par défaut, c'est '80'; en utilisant
- SSL, par exemple, il sera remplacé par le numéro
+ Le port de la machine serveur utilisé pour les
+ communications. Par défaut, c'est '80'; en utilisant
+ SSL, par exemple, il sera remplacé par le numéro
de port HTTP sécurisé.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>SERVER_SIGNATURE</term>
<listitem>
<simpara>
- Chaîne contenant le numéro de version du serveur
- et le nom d'hôte virtuel, qui sont ajoutés aux
- pages générées par le serveur, si cette
+ Chaîne contenant le numéro de version du serveur
+ et le nom d'hôte virtuel, qui sont ajoutés aux
+ pages générées par le serveur, si cette
option est activée.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>PATH_TRANSLATED</term>
<listitem>
<simpara>
- Chemin dans le système de fichier (pas le document root-)
- jusqu'au script courant, une fois que le serveur à fait
+ Chemin dans le système de fichier (pas le document root-)
+ jusqu'au script courant, une fois que le serveur à fait
une chemin traduction virtuel->réél.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>SCRIPT_NAME</term>
<listitem>
<simpara>
- Contient le nom du script courant. Cela sert lorsque
+ Contient le nom du script courant. Cela sert lorsque
les pages doivent s'appeler elles-mêmes.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>REQUEST_URI</term>
<listitem>
@@ -405,49 +367,42 @@
</varlistentry>
</variablelist>
</para>
-
</sect2>
-
<sect2 id="language.variables.predefined.environment">
<title>Variables d'environnement</title>
-
<simpara>
- Ces variables sont importées dans l'espace de nom global
- de PHP, depuis l'environnement sous lequel PHP fonctionne. Beaucoup
- d'entre elles sont fournies par le shell qui exécute PHP et
+ Ces variables sont importées dans l'espace de nom global
+ de PHP, depuis l'environnement sous lequel PHP fonctionne. Beaucoup
+ d'entre elles sont fournies par le shell qui exécute PHP et
différents systèmes étant suceptibles
- de disposer de différents shells, une liste définitive
- est impossible à établir. Reportez vous à la
+ de disposer de différents shells, une liste définitive
+ est impossible à établir. Reportez vous à la
documentation de votre shell, pour connaître la liste des
variables d'environnement prédéfinies.
</simpara>
<simpara>
- Les autres variables d'environments inclues les variables CGI,
- placées ici, quelque fois la méthode
+ Les autres variables d'environments inclues les variables CGI,
+ placées ici, quelque fois la méthode
d'éxécution de PHP (CGI ou module).
</simpara>
</sect2>
-
<sect2 id="language.variables.predefined.php">
<title>Variables PHP</title>
-
<simpara>
Ces variables sont créées par PHP lui_même.
Les variables <varname>$HTTP_*_VARS</varname> ne sont disponibles
- que si l'option de configuration
+ que si l'option de configuration
<link linkend="ini.track-vars">track_vars</link> a été
activée.
</simpara>
-
<note>
<para>
- Depuis PHP 4.0.3,
+ Depuis PHP 4.0.3,
<link linkend="ini.track-vars">track_vars</link> est toujours
activé, quelque soit la configuration.
</para>
</note>
-
<para>
- Si la directive
+ Si la directive
<link linkend="ini.register-globals">register_globals</link> est activée,
alors ces variables seront aussi disponibles comme variable
global du script : c'est à dire, indépendamment des tableaux
@@ -460,32 +415,29 @@
devez prendre toutes les dispositions possibles pour vous assurer
que les données utilisées sont sûres.
</para>
-
<para>
<variablelist>
<varlistentry>
<term>argv</term>
<listitem>
<simpara>
- Tableau des rguments passées au script. Lorsque le script
- est appelé en ligne de commande, cela dconne accès
- aux arguments, comme en langage C. Lorsque le script est
- appelé avec la méthode GET, ce tableau contiendra
+ Tableau des rguments passées au script. Lorsque le script
+ est appelé en ligne de commande, cela dconne accès
+ aux arguments, comme en langage C. Lorsque le script est
+ appelé avec la méthode GET, ce tableau contiendra
la chaîne de requête.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>argc</term>
<listitem>
<simpara>
- Contient le nombre de paramètres de la ligne de commande
+ Contient le nombre de paramètres de la ligne de commande
passés au script (s'il fonctionne en ligne de commande).
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>PHP_SELF</term>
<listitem>
@@ -495,37 +447,34 @@
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_COOKIE_VARS</term>
<listitem>
<simpara>
Un tableau associatif des variables passées au script
courant via les HTTP cookies. Uniquement possible si le suivi
- des variables a été activé avec
- la directive générale
- <link linkend="ini.track-vars">track_vars</link> ou
- avec la directive locale
- <computeroutput><?php_track_vars?></computeroutput>.
+ des variables a été activé avec
+ la directive générale
+ <link linkend="ini.track-vars">track_vars</link> ou
+ avec la directive locale
+ <computeroutput><? php_track_vars ?></computeroutput>.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_GET_VARS</term>
<listitem>
<simpara>
Un tableau associatif des variables passées au script
courant via les HTTP GET. Uniquement possible si le suivi des
- variables a été activé avec la directive
- générale
- <link linkend="ini.track-vars">track_vars</link> ou
- avec la directive locale
- <computeroutput><?php_track_vars?></computeroutput>.
+ variables a été activé avec la directive
+ générale
+ <link linkend="ini.track-vars">track_vars</link> ou
+ avec la directive locale
+ <computeroutput><? php_track_vars ?></computeroutput>.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_POST_VARS</term>
<listitem>
@@ -533,21 +482,20 @@
Un tableau associatif des variables passées au script
courant via les HTTP POST. Uniquement possible si le suivi des
variables a été activé avec la directive
- générale
- <link linkend="ini.track-vars">track_vars</link> ou
- avec la directive locale
- <computeroutput><?php_track_vars?></computeroutput>.
+ générale
+ <link linkend="ini.track-vars">track_vars</link> ou
+ avec la directive locale
+ <computeroutput><? php_track_vars ?></computeroutput>.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_POST_FILES</term>
<listitem>
<simpara>
Un tableau associatif contenant les informations sur les
fichiers téléchargés avec la méthode
- HTTP POST. Reportez vous au chapitre
+ HTTP POST. Reportez vous au chapitre
<link linkend="features.file-upload.post-method">
Téléchargement par méthode POST</link> pour plus de
détails
sur le contenu de <varname>$HTTP_POST_FILES</varname>.
@@ -558,23 +506,21 @@
</para>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_ENV_VARS</term>
<listitem>
<simpara>
- Un tableau associatif des variables passées au script
+ Un tableau associatif des variables passées au script
par l'environnement parent.
</simpara>
</listitem>
</varlistentry>
-
<varlistentry>
<term>HTTP_SERVER_VARS</term>
<listitem>
<simpara>
- Un tableau associatif des variables passées au script
- par le serveur HTTP. Ces variables sont analogues
+ Un tableau associatif des variables passées au script
+ par le serveur HTTP. Ces variables sont analogues
aux variables décrites ci-dessus.
</simpara>
</listitem>
@@ -583,173 +529,157 @@
</para>
</sect2>
</sect1>
-
<sect1 id="language.variables.scope">
<title>Portée des variables</title>
-
<simpara>
- La portée d'une variable dépends du contexte
- dans lequel la variable est définie. Pour la plupart des
- variables, la portée concerne la totalité d'un script
- PHP. Mais, lorsque vous définissez une fonction, la
- portée d'une variable définie dans cette fonction
+ La portée d'une variable dépends du contexte
+ dans lequel la variable est définie. Pour la plupart des
+ variables, la portée concerne la totalité d'un script
+ PHP. Mais, lorsque vous définissez une fonction, la
+ portée d'une variable définie dans cette fonction
est locale à la fonction. Par exemple:
</simpara>
<informalexample>
<programlisting role="php">
+<?php
$a = 1;
include "b.inc";
</programlisting>
</informalexample>
<simpara>
- Ici, la variable $a sera accessible dans le script inclus
- <filename>b.inc</filename>. Cependant, dans les fonctions
+ Ici, la variable $a sera accessible dans le script inclus
+ <filename>b.inc</filename>. Cependant, dans les fonctions
définies par l'utilisateur, une nouvelle définition
- de cette variable sera donnée, limitée à la
- fonction. Toute variable utilisée dans une fonction est
- par définition, locale. Par exemple :
+ de cette variable sera donnée, limitée à la
+ fonction. Toute variable utilisée dans une fonction est
+ par définition, locale. Par exemple :
</simpara>
-
<informalexample>
- <programlisting role="php">
-$a = 1; /* portée global */
-
-Function Test () {
- echo $a; /* portée locale */
-}
-
+ <programlisting role="php">
+<?php
+$a = 1; /* portée global */
+Function Test () {
+ echo $a; /* portée locale */
+}
Test ();
</programlisting>
</informalexample>
-
<simpara>
- Le script n'affichera rien à l'écran car
+ Le script n'affichera rien à l'écran car
la fonction <function>echo</function> utilise la variable locale $a,
et celle-ci n'a pas été assignée
- préalablement dans la fonction. Vous pouvez noter que
- ce concept diffère un petit peu du langage C dans
- lequel une variable globale est automatiquement accessible dans
- les fonctions, à moins d'être redéfinie
- localement dans la fonction. Cela peut poser des problèmes
- si vous redéfinissez des variables globales localement.
- En PHP, une variable globale doit être
- déclarée à l'intérieure de chaque
+ préalablement dans la fonction. Vous pouvez noter que
+ ce concept diffère un petit peu du langage C dans
+ lequel une variable globale est automatiquement accessible dans
+ les fonctions, à moins d'être redéfinie
+ localement dans la fonction. Cela peut poser des problèmes
+ si vous redéfinissez des variables globales localement.
+ En PHP, une variable globale doit être
+ déclarée à l'intérieure de chaque
fonction afin de pouvoir être utilisée dans cette
fonction. Par exemple:
</simpara>
-
<informalexample>
<programlisting role="php">
+<?php
$a = 1;
$b = 2;
-
Function Sum () {
global $a, $b;
-
$b = $a + $b;
-}
-
+}
Sum ();
echo $b;
</programlisting>
</informalexample>
<simpara>
- Le script ci-dessus va afficher la valeur "3".
- En déclarant global les variables $a et $b localement
- dans la fonction, toutes les références à
- ces variables concerneront les variables globales. Il n'y a
- aucune limite au nombre de variables globales qui peuvent
+ Le script ci-dessus va afficher la valeur "3".
+ En déclarant global les variables $a et $b localement
+ dans la fonction, toutes les références à
+ ces variables concerneront les variables globales. Il n'y a
+ aucune limite au nombre de variables globales qui peuvent
être manipulées par une fonction.
</simpara>
-
<simpara>
- Une deuxième méthode pour accéder aux
- variables globales est d'utiliser le tableau associatif
- prédéfini $GLOBALS. Le pécédent
- exemple peut être réécrit de la
+ Une deuxième méthode pour accéder aux
+ variables globales est d'utiliser le tableau associatif
+ prédéfini $GLOBALS. Le pécédent
+ exemple peut être réécrit de la
manière suivante:
</simpara>
-
<informalexample>
<programlisting role="php">
+<?php
$a = 1;
$b = 2;
-
-Function Sum () {
+function somme() {
$GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"];
-}
-
-Sum ();
+}
+somme();
echo $b;
</programlisting>
</informalexample>
-
<simpara>
- Le tableau $GLOBALS est un tableau associatif avec le nom
- des variables globales comme clef et les valeurs des éléments
+ Le tableau $GLOBALS est un tableau associatif avec le nom
+ des variables globales comme clef et les valeurs des éléments
du tableau comme valeur des variables.
</simpara>
-
<simpara>
- Une autre caractéristique importante de la portée des variables
est
- la notion de variable <emphasis>static</emphasis>. Une variable statique a
- une portée locale uniquement mais elle ne perd pas sa valeur lorsque le
+ Une autre caractéristique importante de la portée des variables
+est
+ la notion de variable <emphasis>static</emphasis>. Une variable statique a
+ une portée locale uniquement mais elle ne perd pas sa valeur lorsque le
script appelle la fonction. Prenons l'exemple suivant:
</simpara>
-
<informalexample>
<programlisting role="php">
-Function Test () {
+<?php
+function Test() {
$a = 0;
echo $a;
$a++;
}
</programlisting>
</informalexample>
-
<simpara>
- Cette fonction est un peu inutile car à chaque fois
+ Cette fonction est un peu inutile car à chaque fois
qu'elle est appelée, elle initialise $a à 0 et
- affiche "0". L'incrémentation de la variable ($a++)
- ne sert pas à grand chose car dès que la
- fonction est terminée la variable disparaît.
- Pour faire une fonction de comptage utile, c'est-à-dire qui
- ne perdra pas la trace du compteur, la variable $a est
+ affiche "0". L'incrémentation de la variable ($a++)
+ ne sert pas à grand chose car dès que la
+ fonction est terminée la variable disparaît.
+ Pour faire une fonction de comptage utile, c'est-à-dire qui
+ ne perdra pas la trace du compteur, la variable $a est
déclarée comme une variable statique:
</simpara>
-
<informalexample>
<programlisting role="php">
-Function Test () {
+<?php
+function test() {
static $a = 0;
echo $a;
$a++;
}
</programlisting>
</informalexample>
-
<simpara>
- Maintenant, à chaque fois que la fonction Test() est
- appelée, elle affichera une valeur de $a incrémentée
+ Maintenant, à chaque fois que la fonction Test() est
+ appelée, elle affichera une valeur de $a incrémentée
de 1.
</simpara>
-
<simpara>
- Les variables statiques sont essentielles lorsque vous faites des
- appels récursifs à une fonction. Une fonction
- récursive est une fonction qui s'appelle elle-même.
- Il faut faire attention lorsque vous écrivez une fonction
- récursive car il est facile de faire une boucle infinie.
- Vous devez vérifier que vous avez bien une condition qui
- permet de terminer votre récursivité. La fonction
+ Les variables statiques sont essentielles lorsque vous faîtes des
+ appels récursifs à une fonction. Une fonction
+ récursive est une fonction qui s'appelle elle-même.
+ Il faut faire attention lorsque vous écrivez une fonction
+ récursive car il est facile de faire une boucle infinie.
+ Vous devez vérifier que vous avez bien une condition qui
+ permet de terminer votre récursivité. La fonction
suivante compte récursivement jusqu'à 10:
</simpara>
-
<informalexample>
<programlisting role="php">
-Function Test () {
+<?php
+function test() {
static $count = 0;
-
$count++;
echo $count;
if ($count < 10) {
@@ -757,94 +687,82 @@
}
$count--;
}
+?>
</programlisting>
</informalexample>
-
</sect1>
-
<sect1 id="language.variables.variable">
<title>Les variables dynamiques</title>
-
<simpara>
- Il est pratique d'avoir parfois des noms de variables qui sont variables.
+ Il est pratique d'avoir parfois des noms de variables qui sont variables.
C'est-à-dire un nom de variable qui affecté et utilisé
- dynamiquement. Une variable classique est affecté avec
+ dynamiquement. Une variable classique est affecté avec
l'instruction suivante:
</simpara>
-
<informalexample>
<programlisting role="php">
+<?php
$a = "bonjour";
</programlisting>
</informalexample>
-
<simpara>
- Une variable dynamique prend la valeur d'une variable et l'utilise
- comme nom d'une autre variable. Dans l'exemple ci-dessous,
- <emphasis>hello</emphasis>, peut être utilisé comme le nom d'une
- variable en utilisant le "$$" précédent la variable.
+ Une variable dynamique prend la valeur d'une variable et l'utilise
+ comme nom d'une autre variable. Dans l'exemple ci-dessous,
+ <emphasis>hello</emphasis>, peut être utilisé comme le nom d'une
+ variable en utilisant le "$$" précédent la variable.
C'est-à-dire
</simpara>
-
<informalexample>
<programlisting role="php">
+<?php
$$a = "monde";
</programlisting>
</informalexample>
-
<simpara>
- A ce niveau, deux variables ont été définies et
- stockées dans l'arbre des symboles PHP: $a avec comme valeur
- "bonjour" et $bonjour avec comme valeur "monde". Alors, l'instruction
+ A ce niveau, deux variables ont été définies et
+ stockées dans l'arbre des symboles PHP: $a avec comme valeur
+ "bonjour" et $bonjour avec comme valeur "monde". Alors, l'instruction
</simpara>
-
<informalexample>
<programlisting role="php">
+<?php
echo "$a ${$a}";
</programlisting>
</informalexample>
-
<simpara>
produira le même affichage que :
</simpara>
-
<informalexample>
- <programlisting>
+ <programlisting role="php">
echo "$a $bonjour";
</programlisting>
</informalexample>
-
<simpara>
c'est-à-dire : <emphasis>bonjour monde</emphasis>.
</simpara>
-
<simpara>
- Afin de pouvoir utiliser les variables dynamiques avec les tableaux,
+ Afin de pouvoir utiliser les variables dynamiques avec les tableaux,
vous avez a résoudre un problème ambigu. Si vous
- écrivez $$a[1], le parseur a besoin de savoir si vous
- parler de la variable qui a pour nom $a[1] ou bien si vous voulez
- l'index [1] de la variable $$a. La syntaxe pour résoudre
- cette ambiguité est la suivante: ${$a[1]} pour le premier
+ écrivez $$a[1], le parseur a besoin de savoir si vous
+ parler de la variable qui a pour nom $a[1] ou bien si vous voulez
+ l'index [1] de la variable $$a. La syntaxe pour résoudre
+ cette ambiguité est la suivante: ${$a[1]} pour le premier
cas, et ${$a}[1] pour le deuxième.
</simpara>
</sect1>
-
<sect1 id="language.variables.external">
<title>Variables externes à PHP</title>
-
<sect2 id="language.variables.external.form">
<title>Formulaires HTML (GET et POST)</title>
-
<simpara>
Lorsqu'un formulaire est envoyé à un script PHP,
- toutes les variables du formulaire seront automatiquement disponibles
+ toutes les variables du formulaire seront automatiquement disponibles
dans le script. Par exemple, considérons le formulaire suivant:
</simpara>
-
<para>
<example>
<title>Exemple avec un formulaire simple</title>
- <programlisting role="php">
+ <programlisting role="html">
<form action="foo.php3" method="post">
Name: <input type="text" name="name"><br>
<input type="submit">
@@ -852,25 +770,22 @@
</programlisting>
</example>
</para>
-
<simpara>
- Lorsque ce formulaire est envoyé, le PHP va créer la variable
- <computeroutput>$name</computeroutput>, qui contiendra la valeur
+ Lorsque ce formulaire est envoyé, le PHP va créer la variable
+ <computeroutput>$name</computeroutput>, qui contiendra la valeur
que vous avez entré dans le champs <emphasis>Name:</emphasis>
du formulaire.
</simpara>
-
<simpara>
- Le PHP permet aussi l'utilisation des tableaux dans le contexte de formulaire,
- mais seulement des tableaux à une seule dimension. Comme cela, vous
pouvez
- rassembler des variables ou utiliser cette fonctionnalité
- pour récupérer les valeurs d'un choix multiple :
+ Le PHP permet aussi l'utilisation des tableaux dans le contexte de formulaire,
+ mais seulement des tableaux à une seule dimension. Comme cela, vous
+pouvez
+ rassembler des variables ou utiliser cette fonctionnalité
+ pour récupérer les valeurs d'un choix multiple :
</simpara>
-
<para>
<example>
<title>Variables complexes de formulaire</title>
- <programlisting role="php">
+ <programlisting role="html">
<form action="array.php" method="post">
Name: <input type="text" name="personal[name]"><br>
Email: <input type="text" name="personal[email]"><br>
@@ -885,171 +800,153 @@
</programlisting>
</example>
</para>
-
<simpara>
- Si l'option "track_vars" est activée, soit par l'option de compilation
- <link linkend="ini.track-vars">track_vars</link>, soit par la directive de
- configuration <computeroutput><?php_track_vars?></computeroutput>,
- les variables transmises par les méthodes POST et GET
- pourront aussi être trouvées dans le tableau
- associatif global $HTTP_POST_VARS ou $HTTP_GET_VARS
+ Si l'option "track_vars" est activée, soit par l'option de compilation
+ <link linkend="ini.track-vars">track_vars</link>, soit par la directive de
+ configuration <computeroutput><? php_track_vars ?></computeroutput>,
+ les variables transmises par les méthodes POST et GET
+ pourront aussi être trouvées dans le tableau
+ associatif global $HTTP_POST_VARS ou $HTTP_GET_VARS
suivant la méthode utlisée.
</simpara>
-
<sect3 id="language.variables.external.form.submit">
<title>Bouton "submit" sous forme d'image</title>
-
<simpara>
- Lorsque vous envoyez le résultat d'un formulaire, vous
- pouvez utiliser une image au lieu du bouton "submit" standard
+ Lorsque vous envoyez le résultat d'un formulaire, vous
+ pouvez utiliser une image au lieu du bouton "submit" standard
en utilisant un tag :
</simpara>
-
<informalexample>
- <programlisting role="php">
+ <programlisting role="html">
<input type=image src="image.gif" name="sub">
</programlisting>
</informalexample>
-
<simpara>
- Lorsqu'un utilisateur clique sur l'image, le formulaire sera
- transmis au serveur avec deux variables de plus, sub_x et
- sub_y. Ces deux variables contiennent les coordonnées
- de l'endroit oú l'utilisateur à cliqué. Les
- utilisateurs expérimentés remarquerons que les noms
- de variables sont transmis avec une virgule à la place du
- caractère "_", mais le PHP fait la conversion
+ Lorsqu'un utilisateur clique sur l'image, le formulaire sera
+ transmis au serveur avec deux variables de plus, sub_x et
+ sub_y. Ces deux variables contiennent les coordonnées
+ de l'endroit oú l'utilisateur à cliqué. Les
+ utilisateurs expérimentés remarquerons que les noms
+ de variables sont transmis avec une virgule à la place du
+ caractère "_", mais le PHP fait la conversion
automatiquement.
</simpara>
</sect3>
-
</sect2>
-
<sect2 id="language.variables.external.cookies">
<title>HTTP Cookies</title>
-
<simpara>
- Le PHP supporte les cookies HTTP de manière totalement
- transparente, comme défini dans les
- <ulink url="&spec.cookies;">Netscape's Spec</ulink>. Les cookies
- sont un mécanisme permettant de stocker des données
- sur la machine cliente à des fins d'authentification de
- l'utilisateur. Vous pouvez établir un cookie grâce à
- la fonction <function>setcookie</function>. Les cookies
- font partie intégrante du "header" HTTP, et donc
- la fonction <function>setcookie</function> doit être
- appelé avant que le moindre affichage ne soit envoyé
- au navigateur. C'est la même restriction que pour la fonction
- <function>header</function>. Tout cookie envoyé depuis le
- client sur le serveur sera automatiquement stocké sous
+ Le PHP supporte les cookies HTTP de manière totalement
+ transparente, comme défini dans les
+ <ulink url="&spec.cookies;">Netscape's Spec</ulink>. Les cookies
+ sont un mécanisme permettant de stocker des données
+ sur la machine cliente à des fins d'authentification de
+ l'utilisateur. Vous pouvez établir un cookie grâce à
+ la fonction <function>setcookie</function>. Les cookies
+ font partie intégrante du "header" HTTP, et donc
+ la fonction <function>setcookie</function> doit être
+ appelé avant que le moindre affichage ne soit envoyé
+ au navigateur. C'est la même restriction que pour la fonction
+ <function>header</function>. Tout cookie envoyé depuis le
+ client sur le serveur sera automatiquement stocké sous
forme de variable, comme pour la méthode POST ou GET.
</simpara>
-
<simpara>
- Si vous souhaitez assigner plusieurs valeurs à un seul
- cookie, il vous faut ajouter les caractères
- <emphasis>[]</emphasis> au nom de votre cookie.
- Par exemple :
+ Si vous souhaitez assigner plusieurs valeurs à un seul
+ cookie, il vous faut ajouter les caractères
+ <emphasis>[]</emphasis> au nom de votre cookie.
+ Par exemple :
</simpara>
-
<informalexample>
<programlisting role="php">
+<?php
setcookie ("MonCookie[]", "test", time()+3600);
+?>
</programlisting>
</informalexample>
-
<simpara>
- Il est à noter qu'un cookie remplace le cookie
- précédent par un cookie de même nom tant que
- le "path" ou le domaine sont identiques. Donc, pour une application
- de caddie, vous devez implémenter un compteur et
+ Il est à noter qu'un cookie remplace le cookie
+ précédent par un cookie de même nom tant que
+ le "path" ou le domaine sont identiques. Donc, pour une application
+ de caddie, vous devez implémenter un compteur et
l'incrémenter au fur et à mesure. C'est-à-dire:
</simpara>
-
<example>
- <title>Exemple setcookie</title>
+ <title>Exemple avec <function>setcookie</function></title>
<programlisting role="php">
-$Count++;
+<?php
+$compte++;
SetCookie ("Compte", $compte, time()+3600);
-SetCookie ("Caddie[$Compte]", $item, time()+3600);
+SetCookie ("Caddie[$compte]", $item, time()+3600);
+?>
</programlisting>
</example>
-
</sect2>
-
<sect2 id="language.variables.external.environment">
<title>Variables d'environnement </title>
-
<para>
- Le PHP fait en sorte que les variables d'environnement soient accessibles
- directement comme des variables PHP normales.
-
+ Le PHP fait en sorte que les variables d'environnement soient accessibles
+ directement comme des variables PHP normales.
<informalexample>
<programlisting role="php">
-echo $HOME; /* Affiche la valeur de la variable d'environnement HOME,
+<?php
+echo $HOME; /* Affiche la valeur de la variable d'environnement HOME,
si celle-ci est affectée. */
+?>
</programlisting>
</informalexample>
</para>
-
<para>
- Même si le PHP crée les variables lors de l'utilisation
- des méthodes GET, POST et cookie, il est de temps en temps
- préférable de transmettre explicitement la valeur de
- la variable afin d'être sûre de la valeur.
- La fonction <function>getenv</function> peut être
- utilisé pour récupéré la valeur
- des variables d'environnement. Vous pouvez aussi affecter
- une variable d'environnement grâce à la fonction
+ Même si le PHP crée les variables lors de l'utilisation
+ des méthodes GET, POST et cookie, il est de temps en temps
+ préférable de transmettre explicitement la valeur de
+ la variable afin d'être sûre de la valeur.
+ La fonction <function>getenv</function> peut être
+ utilisé pour récupéré la valeur
+ des variables d'environnement. Vous pouvez aussi affecter
+ une variable d'environnement grâce à la fonction
<function>putenv</function>.
</para>
</sect2>
-
<sect2 id="language.variables.external.dot-in-names">
<title>Cas des points dans les noms de variables</title>
-
<para>
- Typiquement, PHP ne modifie pas les noms des variables lorsqu'elles
- sont passées à un script. Cependant, il faut noter que
- les points (.) ne sont pas autorisés dans les noms de variables
- PHP. Pour cette raison, jetez un oeil sur :
+ Typiquement, PHP ne modifie pas les noms des variables lorsqu'elles
+ sont passées à un script. Cependant, il faut noter que
+ les points (.) ne sont pas autorisés dans les noms de variables
+ PHP. Pour cette raison, jetez un oeil sur :
<programlisting role="php">
-$varname.ext; /* invalid variable name */
+<?php
+$varname.ext; /* nom de variable invalide */
+?>
</programlisting>
- Dans ce cas, l'analyseur croit voir la variable nommée
- $varname, suivie par l'opérateur de concaténation,
- et suivi encore par la chaîne non-guillemetée (une
- chaîne sans guillemets, et qui n'a pas de signification
+ Dans ce cas, l'analyseur croit voir la variable nommée
+ $varname, suivie par l'opérateur de concaténation,
+ et suivi encore par la chaîne non-guillemetée (une
+ chaîne sans guillemets, et qui n'a pas de signification
particulière). Visiblement, ce n'est pas ce qu'on attendait...
</para>
-
<para>
- Pour cette raison, il est important de noter que PHP remplacera
- automatiquement les points des noms de variables entrantes par
+ Pour cette raison, il est important de noter que PHP remplacera
+ automatiquement les points des noms de variables entrantes par
des soulignés (underscore).
</para>
-
</sect2>
-
<sect2 id="language.variables.determining-type-of">
<title>Détermination du type des variables</title>
-
<para>
- Parce que le PHP détermine le type des variables et
- les convertit (généralement) comme il faut,
- ce n'est pas toujours le type de variable que vous souhaitez.
- PHP inclus des fonctions permettant de déterminer le
- type d'une variable. Les fonctions <function>gettype</function>,
+ Parce que le PHP détermine le type des variables et
+ les convertit (généralement) comme il faut,
+ ce n'est pas toujours le type de variable que vous souhaitez.
+ PHP inclus des fonctions permettant de déterminer le
+ type d'une variable. Les fonctions <function>gettype</function>,
<function>is_long</function>,
<function>is_double</function>, <function>is_string</function>,
<function>is_array</function>, et <function>is_object</function>.
</para>
</sect2>
-
</sect1>
-
</chapter>
-
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
Index: phpdoc/fr/language/basic-syntax.xml
diff -u phpdoc/fr/language/basic-syntax.xml:1.3 phpdoc/fr/language/basic-syntax.xml:1.4
--- phpdoc/fr/language/basic-syntax.xml:1.3 Wed Dec 13 05:38:47 2000
+++ phpdoc/fr/language/basic-syntax.xml Fri Jan 12 02:56:51 2001
@@ -8,9 +8,9 @@
<para>
<example>
<title>Le passage du HTML au PHP </title>
- <programlisting>
-1. <? echo ("Ceci est un exemple d'affichage à l'écran en PHP, sous
forme d'expression SGML.\n"); ?>
-2. <?php echo("Si vous voulez afficher du XML ou du XHTML, faites comme
ceci.\n"); ?>
+ <programlisting role="php">
+1. <? echo ("Ceci est un exemple d'affichage à l'écran en PHP, sous
+forme d'expression SGML.\n"); ?>
+2. <?php echo("Si vous voulez afficher du XML ou du XHTML, faîtes comme
+ceci.\n"); ?>
3. <script language="php">
echo ("Certains éditeur HTML (comme FrontPage)
n'accepte pas les expressions telles que celle ci.");
@@ -21,8 +21,8 @@
</example>
</para>
<para>
- La deuxième méthode est généralement
utilisée,
- car elle permet une implémentation aisée de PHP avec la
+ La deuxième méthode est généralement utilisée,
+ car elle permet une implémentation aisée de PHP avec la
prochaine génération de XHTML.
</para>
<para>
@@ -58,15 +58,15 @@
par un point virgule à chaque fin d'instruction.
</simpara>
<para>
- Le tag de fin (?>) implique la fin d'un instruction, et donc
+ La balise de fin (?>) implique la fin d'un instruction, et donc
ajoute implicitement un point virgule. Les deux exemples suivants
sont équivalents.
<informalexample>
- <programlisting>
+ <programlisting role="php">
<?php
echo "Ceci est un test";
-?>
-<?php echo "Ceci est un test" ?>
+?>
+<?php echo "Ceci est un test" ?>
</programlisting>
</informalexample>
</para>
@@ -76,14 +76,14 @@
<para>
Le PHP supporte les commentaires comme en C, C++ et Shell Unix. Par exemple:
<informalexample>
- <programlisting>
+ <programlisting role="php">
<?php
echo "Ceci est un test"; // Ceci est un commentaire sur une ligne comme en C++
/* Ceci est un commentaire sur plusieurs lignes,
comme en C et C++ */
echo "Ceci est encore un test";
echo "Enfin, le test final"; # Ceci est un commentaire comme en Shell Unix
-?>
+?>
</programlisting>
</informalexample>
</para>
@@ -93,21 +93,22 @@
dépend du premier rencontré.
</simpara>
<informalexample>
- <programlisting>
-<h1>Ceci est un <?php echo "simple";?> exemple.</h1>
+ <programlisting role="php">
+<h1>Ceci est un <?php echo "simple";?> exemple.</h1>
<p>La ligne du dessus affichera 'Ceci est un exemple'.
</programlisting></informalexample>
<simpara>
- Faites attention à ne pas emboîter les
+ Faîtes attention à ne pas emboîter les
commentaires de type 'C', ce qui arrive de temps en temps
lorsque vous voulez commenter une grande partie de code.
</simpara>
- <informalexample><programlisting>
+ <informalexample>
+ <programlisting role="php">
<?php
/*
echo "Ceci est un test"; /* Ce commentaire va poser un problème */
*/
-?>
+?>
</programlisting>
</informalexample>
</sect1>
