 |
 |
 |
 |
|
|
Date: 07/21/00
- Next message: r.m.guerrero <email protected>: "[PHP-DOC] CVS account - Traslation to spanish"
- Previous message: Ghislain Seguy: "[PHP-DOC] cvs: phpdoc /fr Translators"
- Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
bibi Fri Jul 21 03:23:49 2000 EDT
Added files:
/phpdoc/fr/language basic-syntax.xml constants.xml
control-structures.xml expressions.xml
functions.xml oop.xml operators.xml types.xml
variables.xml
Log:
French translation of the php documentation
bibi <email protected>
bibi <email protected>
Index: phpdoc/fr/language/basic-syntax.xml
+++ phpdoc/fr/language/basic-syntax.xml
<chapter id="language.basic-syntax">
<title>La syntaxe de base</title>
<sect1 id="language.basic-syntax.phpmode">
<title>Le passage du HTML au PHP</title>
<para>
Il y a quatre moyens pour passer du mode HTML au mode PHP : </para>
<para>
<example>
<title>Le passage du HTML au PHP </title>
<programlisting>
1. <? echo ("Ceci est un exemple d'affichage à l'écran en PHP.\n"); ?>
2. <?php echo("Si vous voulez afficher du texte, faites comme ceci.\n"); ?>
3. <script language="php">
echo ("Certain éditeur HTML n'accepte pas les délimiteurs ci-dessus.");
</script>
4. <% echo ("Vous pouvez aussi utiliser le style ASP comme délimiteur."); %>
<%= $variable; # ceci est un raccourci pour "<%%echo .." %>
</programlisting>
</example></para>
<para>
La première possibilité n'est valable que si vous l'avez activée. Soit en
faisant appel à la fonction short_tags() (NdT : semble avoir disparu), soit en
utilisant l'option d'exécution
<link linkend="ini.short-open-tag">short_open_tag</link> dans le fichier de
configuration, soit en utilisant l'option de compilation --enable-short-tags.
</para>
<para>
La quatrième possibilité est seulement disponible si vous l'avez activée en
utilisant soit l'option d'exécution <link linkend="ini.asp-tags">asp_tags</link>,
soit en utilisant l'option de compilation --enable-asp-tags compile-time.
<note>
<para>
Le support de la quatrième possibilité, ASP-style, a été ajouté dans la
version 3.0.4.
</para>
</note></para>
<para>
La parenthèse fermante pour un bloc ajoutera automatiquement un retour à la ligne si il y en a un de présent.
</para>
</sect1>
<sect1 id="language.basic-syntax.instruction-separation">
<title>Le séparateur d'instruction</title>
<simpara>
Les instructions sont séparées comme en C ou en Perl par un point virgule à chaque
fin d'instruction.
</simpara>
<para>
Le tag de fin (?>) implique la fin d'un instruction, et donc ajoute implicitement
un point virgule. Les deux exemples suivants sont équivalents.
<informalexample>
<programlisting>
<?php
echo "Ceci est un test";
?>
<?php echo "Ceci est un test" ?>
</programlisting>
</informalexample></para></sect1>
<sect1 id="language.basic-syntax.comments">
<title>Comments</title>
<para>
Le PHP supporte les commentaires comme en C, C++ et Shell Unix. Par exemple:
<informalexample><programlisting>
<?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>
<simpara>
Le premier type de commentaire ne commente que jusqu'à la fin de la ligne ou
bien jusqu'à la fin du bloc, cela dépend du premier rencontré.
</simpara>
<informalexample><programlisting>
<h1>Ceci est un <?# echo "simple";?> exemple.</h1>
<p>La ligne du dessus affichera 'Ceci est un exemple'.
</programlisting></informalexample>
<simpara>
Faites 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>
<?php
/*
echo "Ceci est un test"; /* Ce commentaire va poser un problème */
*/
?>
</programlisting></informalexample></sect1>
</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/constants.xml
+++ phpdoc/fr/language/constants.xml
<chapter id="language.constants">
<title>Les constantes</title>
<simpara>
Le 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 comporent 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>
<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" (ou require), alors le nom
du fichier inclus est renvoyé, et non le nom du fichier parent.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<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 "inclus" (ou require), c'est la
position dans le fichier inclus qui est renvoyé.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term>PHP_VERSION</term>
<listitem>
<simpara>
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>
</varlistentry>
<varlistentry>
<term>PHP_OS</term>
<listitem>
<simpara>
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>
<listitem>
<simpara>
La valeur TRUE.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term>FALSE</term>
<listitem>
<simpara>
La valeur FALSE.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<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.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term>E_WARNING</term>
<listitem>
<simpara>
Dénote un contexte dans lequel le PHP trouve que quelque chose 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>
<varlistentry>
<term>E_PARSE</term>
<listitem>
<simpara>
L’analyseur a rencontré une forme syntaxique invalide dans le script.
Correction de l'erreur impossible.
</simpara>
</listitem>
</varlistentry>
<varlistentry>
<term>E_NOTICE</term>
<listitem>
<simpara>
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.
</simpara>
</listitem>
</varlistentry>
</variablelist></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>
<?php
define("CONSTANT", "Bonjour le monde.");
echo CONSTANT; // affiche "Bonjourle monde."
?>
</programlisting>
</example>
<example>
<title>Utilisatin des constantes __FILE__ et __LINE__ </title>
<programlisting>
<?php
function report_error($file, $line, $message) {
echo "Une erreur a eu lieu dans le fichier $file à la ligne $line: $message.";
}
report_error(__FILE__,__LINE__, "Y a un problème!");
?>
</programlisting>
</example></para>
</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/control-structures.xml
+++ phpdoc/fr/language/control-structures.xml
<chapter id="control-structures">
<title>Les structures de contrôle</title>
<simpara>
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
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> sont les mêmes
en PHP qu'en C :
<informalexample>
<programlisting>
if (expr)
statement
</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 est <literal>FALSE</literal>, l'instruction sera ignorée.
</simpara>
<para>
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">
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
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
<replaceable>$b</replaceable>:
<informalexample>
<programlisting role="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
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 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 <replaceable>$a</replaceable>, et <computeroutput>a est
plus petit que b</computeroutput> sinon:
<informalexample>
<programlisting role="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> 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, à la différence
de l'expression <literal>else</literal>, il n'exécutera l'instruction que si
l'expression condionnelle elseif 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>:
<informalexample>
<programlisting role="php">
if ($a > $b) {
print "a est plus grand que b";
} elseif ($a == $b) {
print "a est égal à b";
} 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
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 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 <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>,
<literal>endfor;</literal>, ou <literal>endswitch;</literal>.
<informalexample>
<programlisting role="php">
<?php if ($a == 5): ?>
A is equal to 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.
</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:
<informalexample>
<programlisting role="php">
if ($a == 5):
print "a equals 5";
print "...";
elseif ($a == 6):
print "a equals 6";
print "!!!";
else:
print "a is neither 5 nor 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.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 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 :
<informalexample>
<programlisting>
while (expr) statement
</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 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
exécutée.
</simpara>
<para>
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:
<informalexample>
<programlisting>
while (expr): statement ... endwhile;
</programlisting>
</informalexample>
</para>
<para>
Les exemples suivants sont identiques, et affichent tous les nombres de 1 à 10:
<informalexample>
<programlisting>
/* 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 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">
$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 é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 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:
<informalexample>
<programlisting role="php">
do {
if ($i < 5) {
print "i n'est pas suffisamment grand";
break;
}
$i *= $factor;
if ($i < $minimum_limit) {
break;
}
print "i est bon";
...process i...
} while(0);
</programlisting>
</informalexample>
</para>
<simpara>
Ne vous inquiétez pas si vous ne comprennez 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:
<informalexample>
<programlisting>
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 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 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 (exécutée).
</simpara>
<simpara>
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
<link linkend="control-structures.break"><literal>break</literal></link>.
</simpara>
<para>
Considérons les exemples suivants. Tous affichent les chiffres de 1 à 10:
<informalexample>
<programlisting role="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) {
break;
}
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
boucle <literal>for</literal> peut être utile parfois.
</simpara>
<para>
PHP supporte aussi la syntaxe alternative suivante pour les boucles
<literal>for</literal> :
<informalexample>
<programlisting>
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. PHP3 ne dispose pas d'une telle fonction; PHP4 en dispose
(voir <link linkend="control-structures.foreach">foreach</link>). En PHP3, 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 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>
</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 à 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>.
</simpara>
<simpara>
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 manière identique :
<informalexample>
<programlisting role="php">
reset ($arr);
while (list(, $value) = each ($arr)) {
echo "Valeur: $value<br>\n";
}
foreach ($arr as $value) {
echo "Valeur: $value<br>\n";
}
</programlisting>
</informalexample>
Les exemples suivants sont aussi fonctionnellement identiques :
<informalexample>
<programlisting role="php">
reset ($arr);
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";
}
</programlisting>
</informalexample>
</para>
<para>
Voici quelques exemples de plus :
<informalexample>
<programlisting role="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
);
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
<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 été interrompues.
</simpara>
<para>
<informalexample>
<programlisting role="php">
$i = 0;
while ($i < 10) {
if ($arr[$i] == "stop") {
break; /* Vous pouvez aussi écrire 'break 1;' ici. */
}
$i++;
}
/* Utilisation de l'argument optionnel. */
$i = 0;
while ( ++$i ) {
switch ( $i ) {
case 5:
echo "à 5<br>\n";
break 1; /* Ne sort que du switch. */
case 10:
echo "à 10; quitting<br>\n";
break 2; /* Sort du switch et du while. */
default:
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.
</simpara>
<simpara>
<literal>continue</literal> accepte un argument numérique optionnel qui vous
indiquera combien de structures emboîtées ont été ignorées.
</simpara>
<para>
<informalexample>
<programlisting role="php">
while (list ($cle, $valeur) = each ($arr)) {
if (!($cle % 2)) { // évite les membres impairs
continue;
}
fonction_quelconque($valeur);
}
$i = 0;
while ($i++ < 5) {
echo "Dehors<br>\n";
while (1) {
echo " Milieu<br>\n";
while (1) {
echo " Intérieur<br>\n";
continue 3;
}
echo "Ceci n'est jamais atteint.<br>\n";
}
echo "Ceci non plus.<br>\n";
}
</programlisting>
</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 à laquelle elle est égale.
C'est exactement à cela que sert l'instruction <literal>switch</literal>.
</simpara>
<para>
Les 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>:
<informalexample>
<programlisting role="php">
if ($i == 0) {
print "i égale 0";
}
if ($i == 1) {
print "i égale 1";
}
if ($i == 2) {
print "i égale 2";
}
switch ($i) {
case 0:
print "i égale 0";
break;
case 1:
print "i égale 1";
break;
case 2:
print "i égale 2";
break;
}
</programlisting>
</informalexample>
</para>
<para>
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. PHP continue d'exécuter les instructions jusqu'à 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 :
<informalexample>
<programlisting role="php">
switch ($i) {
case 0:
print "i égale 0";
case 1:
print "i égale 1";
case 2:
print "i égale 2";
}
</programlisting>
</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).
</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
comparaisons. 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 commande du cas suivant.
<informalexample>
<programlisting role="php">
switch ($i) {
case 0:
case 1:
case 2:
print "i est plus petit que 3 mais n'est pas négatif";
break;
case 3:
print "i égale 3";
}
</programlisting>
</informalexample>
</para>
<para>
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 :
<informalexample>
<programlisting role="php">
switch ($i) {
case 0:
print "i égale 0";
break;
case 1:
print "i égale 1";
break;
case 2:
print "i égale 2";
break;
default:
print "i n'est ni égal à 2, ni à 1, ni à 0.";
}
</programlisting>
</informalexample>
</para>
<para>
Une autre chose à mentionner est que l'instruction <literal>case</literal>
peut être une expression à 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
<link linkend="control-structures.alternative-syntax">syntaxes alternatives</link>).
<informalexample>
<programlisting role="php">
switch ($i):
case 0:
print "i égale 0";
break;
case 1:
print "i égale 1";
break;
case 2:
print "i égale 2";
break;
default:
print "i n'est ni égal à 2, ni à 1, ni à 0";
endswitch;
</programlisting>
</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 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>, 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>.
</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> 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.
</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>. 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 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. Pour cela, il
faut utiliser <function>include</function>.
<informalexample>
<programlisting role="php">
require ('header.inc');
</programlisting>
</informalexample>
</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, 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 */
</programlisting>
</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
<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 inclus. Elle ne doit intervenir dans aucun bloc (entre accolade {}).
En PHP4, 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 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 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
fois un fichier, ou même des fichiers différents.
<informalexample>
<programlisting role="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, comme dans un
<link linkend="control-structures.if">if</link>).
</para>
<para>
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">
/* 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
normale, qui retourne une valeur. Mais cela génère une erreur d'analyse en PHP3.
</simpara>
<example>
<title><function>include</function> en PHP3 et PHP4</title>
<para>
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
echo "Avant le retour<br>\n";
if (1) {
return 27;
}
echo "Après le retour <br>\n";
?>
</programlisting>
</para>
<para>
On suppose que le fichier <filename>main.html</filename> contient ceci :
<programlisting role="php">
<?;php
$retval = include ('test.inc');
echo "Fichier inclus: '$retval'<br>\n";
?>
</programlisting>
</para>
<para>
Lorsque <filename>main.html</filename> est appelé en PHP3, 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 :
<screen>
Avant le retour
Ficher inclus : '27'
</screen>
</para>
<para>
Supposons maintenant que <filename>main.html</filename> a été modifié et contient
maintenant le code suivant :
<programlisting role="php">
<?;php
include ('test.inc');
echo "Retour dans le main.html<br>\n";
?>
</programlisting>
</para>
<para>
En PHP4, l'affichage sera :
<screen>
Avant le retour
Retour dans le main.html
</screen>
Au contraire, PHP3 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 :
<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>
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 ê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 */
</programlisting>
</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
<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>
et <function>virtual</function>.
</simpara>
</sect1>
</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/expressions.xml
+++ phpdoc/fr/language/expressions.xml
<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 de