cvs: phpdoc-fr / language-snippets.ent /language basic-syntax.xml constants.xml control-structures.xml expressions.xml functions.xml oop.xml
operators.xml references.xml types.xml variables.xml

From: Date: Mon, 03 Feb 2003 12:27:12 +0000
Subject: cvs: phpdoc-fr / language-snippets.ent /language basic-syntax.xml constants.xml control-structures.xml expressions.xml functions.xml oop.xml
operators.xml references.xml types.xml variables.xml
Groups: php.doc.fr 
Request: Send a blank email to doc-fr+get-192@lists.php.net to get a copy of this message
dams Mon Feb 3 07:27:12 2003 EDT Modified files: /phpdoc-fr language-snippets.ent /phpdoc-fr/language basic-syntax.xml constants.xml control-structures.xml expressions.xml functions.xml oop.xml operators.xml references.xml types.xml variables.xml Log: keeping up for stability

Index: phpdoc-fr/language-snippets.ent diff -u phpdoc-fr/language-snippets.ent:1.32 phpdoc-fr/language-snippets.ent:1.33 --- phpdoc-fr/language-snippets.ent:1.32 Sat Jan 18 18:38:05 2003 +++ phpdoc-fr/language-snippets.ent Mon Feb 3 07:27:11 2003 @@ -1,13 +1,10 @@ -<!-- PHPDoc snippets $Id: language-snippets.ent,v 1.32 2003/01/18 23:38:05 dams Exp $ --> +<!-- PHPDoc snippets $Id: language-snippets.ent,v 1.33 2003/02/03 12:27:11 dams Exp $ --> <!ENTITY warn.experimental '<warning><simpara>Ce module est <emphasis>EXPERIMENTAL</emphasis>. Cela signifie que le comportement de ces fonctions, leurs noms et concr&egrave;tement, TOUT ce qui est document&eacute; ici peut changer dans un futur proche, SANS PREAVIS! Soyez-en conscient, et utiliser ce module &agrave; vos risques et p&eacute;rils.</simpara></warning>'> <!ENTITY warn.experimental.func '<warning><simpara>Cette fonction est <emphasis>EXPERIMENTALE</emphasis>. Cela signifie que le comportement de cette fonction, son nom et concr&egrave;tement, TOUT ce qui est document&eacute; ici peut changer dans un futur proche, SANS PREAVIS! Soyez-en conscient, et utilisez cette fonction &agrave; vos risques et p&eacute;rils.</simpara></warning>'> <!ENTITY warn.undocumented.func '<warning><simpara>Cette fonction n&#39;est pas document&eacute;e, et seule la liste des arguments est disponible.</simpara></warning>'> -<!ENTITY warn.no-win32-fopen-wrapper '<warning><para>La version Windows -de <literal>PHP</literal> ne supporte pas l&#39;acc&egrave;s aux fichiers distants -avec cette fonction, m&ecirc;me si <link linkend="ini.allow-url-fopen">allow_url_fopen</link> est activ&eacute;. -</para></warning>'> +<!ENTITY warn.no-win32-fopen-wrapper '<warning><para>La version Windows de <literal>PHP</literal> ne supporte pas l&#39;acc&egrave;s aux fichiers distants avec cette fonction, m&ecirc;me si <link linkend="ini.allow-url-fopen">allow_url_fopen</link> est activ&eacute;. </para></warning>'> <!ENTITY tip.ob-capture '<tip><simpara>Comme pour toutes les fonctions qui affichent directement des r&eacute;sultats au navigateur, vous pouvez utiliser <link linkend="ref.outcontrol">les fonctions de gestion des sorties</link> pour capturer le contenu de cette fonction et le sauver, par exemple, dans une cha&icirc;ne.</simpara></tip>'> @@ -16,6 +13,9 @@ <!ENTITY return.success 'Cette fonction retourne &true; en cas de succ&egrave;s, &false; en cas d&#39;&eacute;chec.'> <!ENTITY return.falseproblem '<warning><simpara>Cette fonction peut retourner &false;, mais elle peut aussi retourner une valeur &eacute;quivalent &agrave; &false;, utilisable dans une condition if simple. Utilisez l&#39;<link linkend="language.operators.comparison">op&eacute;rateur ===</link> pour tester la valeur exacte de cette fonction.</simpara></warning>'> + +<!ENTITY warn.imaprecodeyaz '<warning><simpara>L&#39;extension <link linkend="ref.imap">IMAP</link> ne peut &ecirc;tre utilis&eacute;e simultan&eacute;ment avec l&#39;extension <link linkend="ref.recode">recode</link> ou l&#39;extension <link linkend="ref.yaz">YAZ</link>. Ceci est d&ucirc; au fait que ces deux librairies utilisent un symbole interne commun.</simpara></warning>'> + <!-- Notes variees --> <!ENTITY note.not-bin-safe '<warning><simpara>Cette fonction n&#39;est pas capable de g&eacute;rer les cha&icirc;nes binaires!</simpara></warning>'> <!ENTITY note.bin-safe '<note><simpara>Cette fonction g&egrave;re les cha&icirc;nes binaires</simpara></note>'> Index: phpdoc-fr/language/basic-syntax.xml diff -u phpdoc-fr/language/basic-syntax.xml:1.11 phpdoc-fr/language/basic-syntax.xml:1.12 --- phpdoc-fr/language/basic-syntax.xml:1.11 Wed Dec 12 15:50:02 2001 +++ phpdoc-fr/language/basic-syntax.xml Mon Feb 3 07:27:11 2003 @@ -1,91 +1,127 @@ <?xml version="1.0" encoding="iso-8859-1"?> -<!-- $Revision: 1.11 $ --> +<!-- $Revision: 1.12 $ --> <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> + <title>Passer du HTML au PHP</title> <para> Lorsque PHP commence &agrave; traiter un fichier, il ne fait qu'afficher - le texte HTML qu'il rencontre. Si vous renommez un fichier .html - en .php, il s'affichera exactement comme avant. + le texte qu'il rencontre, jusqu'&agrave; ce qu'il rencontre une balise sp&eacute;ciale + qui lui indiquera qu'il peut interpr&eacute;ter le code qui suit. L'analyseur + PHP va alors ex&eacute;cuter ce code, jusqu'&agrave; ce qu'il rencontre une balise + de fin de code PHP. A ce moment l&agrave;, il retourne en mode texte, et + il affiche simplement le contenu. C'est ce m&eacute;canisme qui vous permet + d'inclure du code PHP dans des pages HTML : tout ce qui est plac&eacute; hors + des balises PHP est affich&eacute; sans modification, tandis que le contenu + est ex&eacute;cut&eacute;. </para> <para> - Si vous voulez ins&eacute;rer des commandes PHP dans votre fichier, vous - devez indiquer &agrave; PHP le d&eacute;but d'une telle s&eacute;quence, - en passant en mode PHP. Il y a quatre moyens pour passer du mode HTML au - mode PHP : + Il y a quatre jeux de alises qui servent &agrave; d&eacute;limiter des blocs + de code PHP. Seules deux d'entre elles sont toujours actives : + c'est &lt;?php. . .?&gt; et &lt;script + language="php"&gt;. . .&lt;/script&gt;). Tandis que les autres peuvent + &ecirc;tre activ&eacute;es est d&eacute;sactiv&eacute;es depuis le fichier de configuration + &php.ini;. Les balises courtes et les balises ASP peuvent &ecirc;tre pratiques, + mais elles ne sont pas aussi portables que les versions longues. De plus, + si vous envisagez d'inclure du PHP dans des fichiers + XML ou XHTML, vous devrez utiliser la forme &lt;?php. . .?&gt; pour vous conformer au XML. </para> <para> <example> <title>Le passage du HTML au PHP </title> <programlisting role="php"> -1. &lt;? echo ("Ceci est un exemple d'affichage &agrave; l'&eacute;cran en PHP, sous forme d'expression SGML.\n"); ?&gt; - &lt;?= expression ?&gt; Raccourci de "&lt;? echo expression ?&gt;" -2. &lt;?php echo("Si vous voulez afficher du XML ou du XHTML, faites comme ceci.\n"); ?&gt; -3. &lt;script language="php"> +<![CDATA[ +<?php +1. <?php echo("Si vous voulez afficher du XML ou du XHTML, faites comme ceci.\n"); ?> + +2. <? echo ("Ceci est un exemple d'affichage &agrave; l'&eacute;cran en PHP, sous forme d'expression SGML.\n"); ?> + <?= expression ?> Raccourci de "<? echo expression ?>" + +3. <script language="php"> echo ("Certains &eacute;diteurs HTML (comme FrontPage) n'acceptent pas les expressions telles que celle-ci."); - &lt;/script> -4. &lt;% echo ("Vous pouvez aussi utiliser le style ASP comme d&eacute;limiteur."); %> - &lt;%= $variable; # ceci est un raccourci pour "&lt;%%echo .." %&gt; + </script> + +4. <% echo ("Vous pouvez aussi utiliser le style ASP comme d&eacute;limiteur."); %> + <%= $variable; # ceci est un raccourci pour "<%%echo .." %> +?> +]]> </programlisting> </example> </para> <para> - La deuxi&egrave;me m&eacute;thode est g&eacute;n&eacute;ralement utilis&eacute;e, + La premi&egrave;re m&eacute;thode est g&eacute;n&eacute;ralement utilis&eacute;e, car elle permet une impl&eacute;mentation ais&eacute;e de PHP avec la prochaine g&eacute;n&eacute;ration de XHTML. </para> <para> - La premi&egrave;re possibilit&eacute; n'est valable que si vous - l'avez activ&eacute;e. Soit en faisant appel &agrave; la fonction - short_tags() (NdT : semble avoir disparu), soit en utilisant l'option + La deuxi&egrave;me forme n'est valable que si vous l'avez activ&eacute;e. + Soit en faisant appel &agrave; la fonction + short_tags() (Uniquement en PHP 3), soit en utilisant l'option d'ex&eacute;cution <link linkend="ini.short-open-tag">short_open_tag</link> - dans le fichier de configuration, soit en utilisant l'option de - compilation <link linkend="install.configure.disable-short-tags">--enable-short-tags</link>. + dans le fichier de configuration &php.ini;, soit encore en utilisant + l'option de compilation + <link linkend="install.configure.disable-short-tags">--enable-short-tags</link>. + M&ecirc;me si les balises courtes sont activ&eacute;es dans le fichier de configuration + php.ini-dist, leur utilisation est d&eacute;conseill&eacute;e. </para> <para> - La quatri&egrave;me possibilit&eacute; est seulement disponible - si vous l'avez activ&eacute;e en utilisant soit l'option - d'ex&eacute;cution <link linkend="ini.asp-tags">asp_tags</link>, - soit en utilisant l'option de compilation --enable-asp-tags. + La quatri&egrave;me forme est seulement disponible + si vous l'avez activ&eacute;e en utilisant l'option + d'ex&eacute;cution <link linkend="ini.asp-tags">asp_tags</link>. <note> <para> - Le support de la quatri&egrave;me possibilit&eacute;, - ASP-style, a &eacute;t&eacute; ajout&eacute; dans la - version 3.0.4. + Le support des balises ASP, a &eacute;t&eacute; ajout&eacute; en + PHP 3.0.4. </para> </note> </para> + <note> + <para> + L'utilisation des balises courtes doit &ecirc;tre &eacute;vit&eacute;es lors + du d&eacute;veloppement d'application et de librairies destin&eacute;es &agrave; &ecirc;tre + distribu&eacute;es ou d&eacute;ploy&eacute;es sur des serveurs qui sont hors de votre + contr&ocirc;le, car ces balises ne seront pas forc&eacute;ment support&eacute;es + par le serveur de destination. Pour rendre vos scripts portables + et distribuables, &eacute;vitez les balises courtes. + </para> + </note> <para> - La marque de fermeture d'un bloc (?&gt;) comprend la nouvelle - ligne suivante, s'il y en a une. + La marque de fermeture d'un bloc (?&gt;) comprend le caract&egrave;re de nouvelle + ligne qui le suit imm&eacute;diatement, s'il y en a un. De plus, la balise fermante + implique un point-virgule. Vous n'&ecirc;tes pas oblig&eacute;s de mettre le point-virgule + &agrave; la fin d'un bloc de PHP. </para> <para> <!-- TODO: find a better place for this para --> PHP vous permet d'utiliser des structures telles que : <example> <title>M&eacute;thode avanc&eacute;e</title> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php if ( expression-bool&eacute;enne ) { -?&gt; - &lt;strong&gt;Ceci est vrai.&lt;/strong&gt; -&lt;?php +?> + <strong>Ceci est vrai.</strong> +<?php } else { -?&gt; -&lt;strong&gt;Ceci est faux.&lt;/strong&gt; -&lt;?php +?> +<strong>Ceci est faux.</strong> +<?php } -?&gt; +?> +]]> </programlisting> </example> - Cela fonctionne comme on peut s'y attendre, car PHP traite le texte - entre ?&gt; et &lt;?php comme une fonction <function>echo</function>, - sans remplacer les variables &eacute;ventuelles par leur valeur. + Cela fonctionne comme on peut s'y attendre, car PHP affiche le texte + entre les balises ?&gt; et &lt;?php sans modification. L'exemple ci-dessus + est tr&egrave;s simple, mais c'est un bon syst&egrave;me &agrave; garder en t&ecirc;te pour + afficher de grande quantit&eacute; de texte : c'est m&ecirc;me plus efficace que + d'utiliser les fonctions <function>echo</function> ou + <function>print</function>. </para> </sect1> <sect1 id="language.basic-syntax.instruction-separation"> - <title>Le s&eacute;parateur d'instruction</title> + <title>Le s&eacute;parateur d'instructions</title> <simpara> Les instructions sont s&eacute;par&eacute;es par un point virgule &agrave; chaque fin d'instruction, comme en langage C ou en Perl. @@ -94,60 +130,68 @@ La balise de fin (?&gt;) implique la fin d'un instruction, et donc ajoute implicitement un point virgule. Les deux exemples suivants sont &eacute;quivalents. - <informalexample> + <example> + <title>Le s&eacute;parateur d'instructions</title> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php echo "Ceci est un test"; -?&gt; -&lt;?php echo "Ceci est un test" ?&gt; - </programlisting> - </informalexample> +?> +<?php echo "Ceci est un test" ?> +]]> + </programlisting> + </example> </para> - </sect1> - <sect1 id="language.basic-syntax.comments"> - <title>Commentaires</title> - <para> + </sect1> + <sect1 id="language.basic-syntax.comments"> + <title>Commentaires</title> + <para> Le PHP supporte les commentaires comme en C, C++ et Shell Unix. Par exemple: <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?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 -?&gt; - </programlisting> +?> +]]> + </programlisting> </informalexample> </para> - <simpara> - Le premier type de commentaire ne commente que jusqu'&agrave; la - fin de la ligne ou bien jusqu'&agrave; la fin du bloc, cela - d&eacute;pend du premier rencontr&eacute;. - </simpara> <informalexample> <programlisting role="php"> -&lt;h1>Ceci est un &lt;?php echo "simple";?&gt; exemple.&lt;/h1> -&lt;p> +<![CDATA[ +<h1>Ceci est un <?php # echo "simple";?> exemple.</h1> +<p>L'ent&ecirc;te ci-dessus affiche 'Ceci est un exemple'. +]]> </programlisting> </informalexample> <simpara> - La ligne du dessus affichera 'Ceci est un simple exemple'. - </simpara> - <simpara> - Faites attention &agrave; ne pas embo&icirc;ter les - commentaires de type 'C', ce qui arrive de temps en temps - lorsque vous voulez commenter une grande partie de code. + Faites attention &agrave; ne pas embo&icirc;ter les commentaires de type + langage C, ce qui arrive de temps en temps lorsque vous voulez commenter + une grande partie de code. </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php /* echo "Ceci est un test"; /* Ce commentaire va poser un probl&egrave;me */ */ -?&gt; - </programlisting> +?> +]]> + </programlisting> </informalexample> + <simpara> + Les commentaires // commente jusqu'&agrave; la + fin de la ligne ou bien jusqu'&agrave; la fin du bloc (le premier + des deux). Cela signifie que du code HTML plac&eacute; apr&egrave;s + // ?&gt; sera affich&eacute;, car PHP retourne alors en mode texte + juste apr&egrave;s la balie ?&gt;. + </simpara> </sect1> </chapter> <!-- Keep this comment at the end of the file Index: phpdoc-fr/language/constants.xml diff -u phpdoc-fr/language/constants.xml:1.16 phpdoc-fr/language/constants.xml:1.17 --- phpdoc-fr/language/constants.xml:1.16 Wed Dec 12 15:50:05 2001 +++ phpdoc-fr/language/constants.xml Mon Feb 3 07:27:11 2003 @@ -1,5 +1,5 @@ <?xml version="1.0" encoding="iso-8859-1"?> -<!-- $Revision: 1.16 $ --> +<!-- $Revision: 1.17 $ --> <chapter id="language.constants"> <title>Les constantes</title> <simpara> @@ -27,7 +27,8 @@ </simpara> </note> <simpara> - Les constantes sont accessibles de mani&egrave;re globale. + Les constantes sont accessibles de mani&egrave;re globale. Vous pouvez la d&eacute;finir + n'importe o&ugrave;, et y acc&egrave;der depuis n'importe quelle fonction. </simpara> <sect1 id="language.constants.syntax"> <title>Syntaxe</title> @@ -39,16 +40,16 @@ <simpara> Seuls les types de donn&eacute;es scalaires peuvent &ecirc;tre plac&eacute;s dans une constante : c'est &agrave; dire les types bool&eacute;en, entier, double et - cha&icirc;ne de caract&egrave;res (soit <type>boolean</type>, <type>integer</type>, - <type>double</type> et <type>string</type>). + cha&icirc;ne de caract&egrave;res (soit &boolean;, &integer;, + &double; et &string;). </simpara> <simpara> Vous povuez acc&eacute;der &agrave; la valeur d'une constante en sp&eacute;cifiant simplement son nom. Contrairement aux variables, vous ne devez <emphasis>PAS</emphasis> pr&eacute;fixer le nom de la constante avec <literal>$</literal>. - Vous pouvez aussi utiliser la fonction <function>constant</function>, pour - lire dynamiquement la valeur d'une constante, si vous obtenez le nom - de cette constante dynamiquement (retour de fonction, par exemple). + Vous pouvez aussi utiliser la fonction <function>constant</function>, pour + lire dynamiquement la valeur d'une constante, dont vous obtenez le nom + dynamiquement (retour de fonction, par exemple). Utilisez la fonction <function>get_defined_constants</function> pour conna&icirc;tre la liste de toutes les fonctions d&eacute;finies. </simpara> @@ -62,8 +63,8 @@ </note> <simpara> Lorsque vous utilisez une constante non d&eacute;finie, PHP suppose que vous utilisez - le nom de la constante. Une - <link linkend="features.error-handling">note</link> sera g&eacute;n&eacute;r&eacute;e. Utilisez la + le nom de la constante. Une <link linkend="ref.errorfunc">note</link> + sera g&eacute;n&eacute;r&eacute;e. Utilisez la fonction <function>defined</function> pour savoir si une constante existe ou pas. </simpara> <para> @@ -71,19 +72,19 @@ <itemizedlist> <listitem> <simpara> - Les constantes ne commencent pas par le signe (<literal>$</literal>); + Les constantes ne commencent pas par le signe (<literal>$</literal>); </simpara> </listitem> <listitem> <simpara> - Les constantes sont d&eacute;finies et accessibles &agrave; tout endroit du code, - globalement. + Les constantes sont d&eacute;finies et accessibles &agrave; tout endroit du code, + globalement. </simpara> </listitem> <listitem> <simpara> - Les constantes ne peuvent pas &ecirc;tre red&eacute;finies ou ind&eacute;finies une fois qu'elles - ont &eacute;t&eacute; d&eacute;finies. + Les constantes ne peuvent pas &ecirc;tre red&eacute;finies ou ind&eacute;finies + une fois qu'elles ont &eacute;t&eacute; d&eacute;finies. </simpara> </listitem> <listitem> @@ -97,169 +98,31 @@ <example> <title>Definir une constante</title> <programlisting> -&lt;?php +<![CDATA[ +<?php define("CONSTANTE", "Bonjour le monde."); echo CONSTANTE; // affiche "Bonjour le monde." echo Constante; // affiche "Constante" et une note. -?&gt; +?> +]]> </programlisting> </example> </para> </sect1> <sect1 id="language.constants.predefined"> <title>Constantes pr&eacute;d&eacute;finies</title> - <para> - Les constantes pr&eacute;d&eacute;finies sont toujours disponibles. En voici la liste : - <variablelist> - <varlistentry> - <term>__FILE__ (insensible &agrave; la casse)</term> - <listitem> - <simpara> - Le nom du fichier qui est actuellement ex&eacute;cut&eacute;. - Si cette constante est utilis&eacute;e dans le cadre d'un fichier - "inclus" (apr&egrave;s utilisation de <function>require</function>), - alors le nom du fichier inclus est renvoy&eacute;e, et non le nom - du fichier parent. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>__LINE__ (insensible &agrave; la casse)</term> - <listitem> - <simpara> - Le num&eacute;ro de la ligne qui est actuellement ex&eacute;cut&eacute;e. - Si cette constante est utilis&eacute;e dans le cadre d'un fichier - "inclus" (apr&egrave;s utilisation de <function>require</function>), - c'est la position dans le fichier inclus qui est renvoy&eacute;. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>PHP_VERSION</term> - <listitem> - <simpara> - La cha&icirc;ne de caract&egrave;res de pr&eacute;sentation de la - version du PHP qui est actuellement utilis&eacute;e. Par exemple '4.1.0'. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>PHP_OS</term> - <listitem> - <simpara> - Nom du syst&egrave;me d'exploitation qui est utilis&eacute; par - la machine qui fait tourner le PHP. Parmi les valeurs possibles : - "AIX", "Darwin" (MacOS), "Linux", "SunOS", "WIN32", "WINNT". - Note : cette liste n'est pas exhaustive. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>&true;</term> - <listitem> - <simpara> - La valeur vraie bool&eacute;enne, &true;. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>&false;</term> - <listitem> - <simpara> - La valeur faux bool&eacute;enne, &false;. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>E_ERROR</term> - <listitem> - <simpara> - D&eacute;note une erreur autre qu'une erreur d'analyse ("parse error") - qu'il n'est pas possible de corriger. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>E_WARNING</term> - <listitem> - <simpara> - D&eacute;note un contexte dans lequel le PHP trouve que quelque chose - ne va pas. Mais l'ex&eacute;cution se poursuit tout de m&ecirc;me. - Ces alertes-l&agrave; peuvent &ecirc;tre r&eacute;cup&eacute;r&eacute;es - par le script lui-m&ecirc;me. Un exemple serait une expression - r&eacute;guli&egrave;re (regexp) invalide dans la fonction - <function>ereg</function>. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>E_PARSE</term> - <listitem> - <simpara> - L'analyseur a rencontr&eacute; 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 &ecirc;tre ou non une erreur. - L'ex&eacute;cution continue. Par exemple, le cas de guillemets doubles (") - non referm&eacute;s, ou bien la tentative d'acc&eacute;der &agrave; - une variable qui n'est pas encore affect&eacute;e. - </simpara> - </listitem> - </varlistentry> - </variablelist> - <variablelist> - <varlistentry> - <term>E_ALL</term> - <listitem> - <simpara> - Toutes les constantes E_* rassembl&eacute;es en une seule. Si vous l'utilisez - avec <function>error_reporting</function>, toutes les erreurs et les - probl&egrave;mes que PHP rencontrera seront notifi&eacute;s. - </simpara> - </listitem> - </varlistentry> - </variablelist> - </para> - <para> - Les constantes E_* sont g&eacute;n&eacute;ralement utilis&eacute;es - avec la fonction <function>error_reporting</function>. - </para> - <para> - Vous pouvez d&eacute;finir d'autres constantes en utilisant la fonction - <function>define</function>. - </para> - <para> - Il est &agrave; noter que ce sont des constantes, et non pas des macros - comme en C. Seulement les donn&eacute;es scalaires peuvent &ecirc;tre - repr&eacute;sent&eacute;es par des constantes. - <example> - <title>D&eacute;finition de constantes </title> - <programlisting role="php"> -&lt;?php - define("CONSTANTE", "Bonjour le monde."); - echo CONSTANTE; -// affiche "Bonjour le monde." -?&gt; - </programlisting> - </example> - <example> - <title>Utilisation des constantes __FILE__ et __LINE__ </title> - <programlisting role="php"> -&lt;?php - function rapport_erreur($file, $line, $message) { - echo "Une erreur est survenue dans le fichier $file &agrave; la ligne $line: $message."; - } - rapport_erreur(__FILE__, __LINE__, "Il y a un probl&egrave;me!"); -?&gt; - </programlisting> - </example> - </para> + <simpara> + PHP fournit un grand nombre de constantes pr&eacute;d&eacute;finies. Certaines + constantes sont d&eacute;finies par diff&eacute;rentes extensions, et ne seront + pr&eacute;sentes que si ces extensions sont compil&eacute;es avec &php;, ou bien + si l'extension a &eacute;t&eacute; charg&eacute;e dynamiquement. + </simpara> + + <simpara> + Une liste des constantes pr&eacute;d&eacute;finies est disponible dans la + section + <link linkend="reserved.constants">Constantes pr&eacute;d&eacute;finies</link>. + </simpara> </sect1> </chapter> <!-- Keep this comment at the end of the file Index: phpdoc-fr/language/control-structures.xml diff -u phpdoc-fr/language/control-structures.xml:1.18 phpdoc-fr/language/control-structures.xml:1.19 --- phpdoc-fr/language/control-structures.xml:1.18 Tue Sep 10 22:17:20 2002 +++ phpdoc-fr/language/control-structures.xml Mon Feb 3 07:27:11 2003 @@ -1,5 +1,5 @@ <?xml version="1.0" encoding="iso-8859-1"?> -<!-- $Revision: 1.18 $ --> +<!-- $Revision: 1.19 $ --> <chapter id="control-structures"> <title>Les structures de contr&ocirc;le</title> <simpara> @@ -33,11 +33,15 @@ </informalexample> </para> <simpara> - Comme nous l'avons vu dans le paragraphe consacr&eacute; aux expressions, - <replaceable>expr</replaceable> est &eacute;valu&eacute;e &agrave; - sa vraie valeur. Si l'expression <replaceable>expr</replaceable> est + Comme nous l'avons vu dans le paragraphe consacr&eacute; aux + <link linkend="language.expressions">expressions</link>, + <replaceable>expr</replaceable> est convertie en sa valeur + bool&eacute;enne. Si l'expression <replaceable>expr</replaceable> vaut &true;, PHP ex&eacute;cutera l'instruction et si elle - est &false;, l'instruction sera ignor&eacute;e. + vaut &false;, l'instruction sera ignor&eacute;e. + Plus de d&eacute;tails sur les vlaeurs qui valent &false; est disponbile dans + la section + <link linkend="language.types.boolean.casting">Conversion en bool&eacute;en</link>. </simpara> <para> L'exemple suivant affiche la phrase <computeroutput>a est plus grand @@ -149,12 +153,14 @@ </informalexample> </para> <simpara> - Vous pouvez avoir plusieurs <literal>elseif</literal> qui s'imbriquent - les uns dans les autres, apr&egrave;s un <literal>if</literal> initial. + Vous pouvez avoir plusieurs <literal>elseif</literal> qui se suivent + les uns apr&egrave;s les autres, apr&egrave;s un <literal>if</literal> initial. Le premier <literal>elseif</literal> qui sera &eacute;valu&eacute; &agrave; &true; sera ex&eacute;cut&eacute;. En PHP, vous pouvez aussi &eacute;crire "else if" en deux mots et son comportement sera - identique &agrave; la version en un seul mot. + identique &agrave; la version en un seul mot. La s&eacute;mantique des + deux expression est l&eacute;g&egrave;rement diff&eacute;rente, mais au bout du compte, + le r&eacute;sultat sera exactement le m&ecirc;me. </simpara> <simpara> L'expression <literal>elseif</literal> est ex&eacute;cut&eacute;e @@ -181,13 +187,9 @@ <informalexample> <programlisting role="php"> <![CDATA[ -<?php - if ($a == 5): -?> - A vaut 5 -<?php - endif; - ?> +<?php if ($a == 5): ?> +A &eacute;gal 5 +<?php endif; ?> ]]> </programlisting> </informalexample> @@ -577,41 +579,57 @@ <programlisting role="php"> <![CDATA[ <?php -/* exemple 1: valeurs seules */ +/* exemple foreach 1 : la valeur seulement */ + $a = array (1, 2, 3, 17); + foreach ($a as $v) { - print "Valeur courante de \$a: $v.\n"; + print "Current value of \$a: $v.\n"; } -/* exemple 2: valeurs (avec la cl&eacute; correspondante) */ + +/* exemple foreach 2 : la valeur et sa cl&eacute; d'index */ + $a = array (1, 2, 3, 17); -$i = 0; /* pour l'illustration uniquement */ + +$i = 0; /* uniquement pour l'illustration */ + foreach($a as $v) { print "\$a[$i] => $v.\n"; + $i++; } -/* exemple 3: cl&eacute; et valeur */ + +/* exemple foreach 3 : la cl&eacute; et la valeur */ + $a = array ( "un" => 1, "deux" => 2, "trois" => 3, "dix-sept" => 17 ); + foreach($a as $k => $v) { print "\$a[$k] => $v.\n"; } -/* exemple 4: tableaux multi-dimensionnels */ + +/* exemple foreach 4 : tableaux multi-dimensionnels */ + $a[0][0] = "a"; $a[0][1] = "b"; $a[1][0] = "y"; $a[1][1] = "z"; + foreach($a as $v1) { foreach ($v1 as $v2) { print "$v2\n"; } } -/* exemple 5: tableaux dynamique */ + +/* exemple foreach 5 : tableaux dynamiques */ + foreach(array(1, 2, 3, 4, 5) as $v) { print "$v\n"; } + ?> ]]> </programlisting> @@ -662,6 +680,7 @@ </informalexample> </para> </sect1> + <sect1 id="control-structures.continue"> <title><literal>continue</literal></title> <simpara> @@ -933,10 +952,10 @@ intervenir par tick. </para> <para> - <informalexample> + <example> + <title>Profile a section of PHP code</title> <programlisting role="php"> <![CDATA[ -<PRE> <?php // Un fonction qui enregistre l'heure &agrave; laquelle elle est appel&eacute;e function profile($dump = FALSE){ @@ -949,32 +968,26 @@ } $profile[] = microtime (); } + // Enregistre un gestionnaire de tick register_tick_function("profile"); + // Initialise la fonction avant le bloc de d&eacute;claration profile(); + // Ex&eacute;cute un bloc de code, et appele un tick toutes les deux secondes declare (ticks=2) { for ($x = 1; $x < 50; ++$x) { echo similar_text(md5($x), md5($x*$x)), "<br>"; } } -?> -]]> - </programlisting> - </informalexample> - Pour voir le r&eacute;sultat : - <informalexample> - <programlisting role="php"> -<![CDATA[ -<?php + // Affiche les donn&eacute;es de la variable $profile print_r(profile(TRUE)); ?> -</pre> ]]> </programlisting> - </informalexample> + </example> Cet exemple profile le code PHP dans le bloc de d&eacute;claration, et enregistre l'heure de chaque commande bas niveau. Cette information peut &ecirc;tre r&eacute;utilis&eacute;e pour d&eacute;busquer les segments @@ -993,76 +1006,73 @@ </simpara> </sect2> </sect1> + <sect1 id="function.return"> + <title>return</title> + <simpara> + Si appel&eacute; depuis une fonction, la commande <function>return</function> + termine imm&eacute;diatement la fonction, et retourne l'argument qui lui + est pass&eacute;. <function>return</function> interromp aussi l'ex&eacute;cution + de commande <function>eval</function> ou de scripts. + </simpara> + <simpara> + Si appel&eacute;e depuis l'environnement global, l'ex&eacute;cution du script + est interrompue. Si le script courant &eacute;tait + <function>include</function> ou <function>require</function>, + alors le contr&ocirc;le est rendu au script appelant, et la valeur + retourn&eacute;e sera utilis&eacute;e comme r&eacute;sultat de la fonction + <function>include</function>. Si <function>return</function> est + appel&eacute; depuis le script principal, alors l'ex&eacute;cution du script + s'arr&ecirc;te. Si le script courant est + <link linkend="ini.auto-prepend-file">auto_prepend_file</link> ou + <link linkend="ini.auto-append-file">auto_append_file</link> + dans le fichier &php.ini;, alors l'ex&eacute;cution du script + s'arr&ecirc;te. + </simpara> + <simpara> + Pour plus d'informations, voyez + <link linkend="functions.returning-values">retourner des valeurs</link>. + </simpara> + <note> + <simpara> + Notez que puisque <function>return</function> est une structure de language + et non pas une fonction, les parenth&egrave;ses <emphasis>ne sont pas</emphasis> requises : + en fait, il est classique de les ignorer, m&ecirc;me si cela ne change rien. + </simpara> + </note> + </sect1> <sect1 id="function.require"> <title><function>require</function></title> <simpara> + <function>require</function> inclut et ex&eacute;cute un + fichier PHP. + </simpara> + <simpara> La commande <function>require</function> se remplace elle-m&ecirc;me - par le contenu du fichier sp&eacute;cifi&eacute;, comme les - pr&eacute;processeurs C le font avec la commande <literal>#include</literal>. + par le contenu du fichier sp&eacute;cifi&eacute;, tel que + d&eacute;crit dans la documentation de la fonction <function>include</function>. </simpara> <simpara> - Il est important de noter que lorsqu'un fichier est - <function>include</function> ou <function>require</function>, - les erreurs d'analyse appara&icirc;tront en HTML tout au d&eacute;but - du fichier, et l'analyse du fichier parent ne sera pas interrompue. Pour - cette raison, le code qui est dans le fichier doit &ecirc;tre plac&eacute; - 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 une instruction du langage. Elle ne fonctionne pas comme - les fonctions standards. Par exemple, <function>require</function> - est ind&eacute;pendante des structures de contr&ocirc;le (cela ne sert &agrave; rien - de la placer dans une condition, elle sera toujours ex&eacute;cut&eacute;e). De plus, - elle ne retourne aucune valeur. Lire une valeur retourn&eacute;e par un - <function>require</function> retourne une erreur d'analyse. - </simpara> - <simpara> - Contrairement &agrave; <function>include</function>, - <function>require</function> va <emphasis>toujours</emphasis> lire dans - le fichier cible, m&ecirc;me si la ligne n'est jamais - ex&eacute;cut&eacute;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&eacute;cut&eacute;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&ecirc;me si le code - contenu dans le fichier source est appel&eacute; dans la boucle, - <function>require</function> n'est ex&eacute;cut&eacute; qu'une - fois. - </simpara> - <para> - Cela signifie qu'on ne peut pas mettre un - <function>require</function> dans une boucle, et s'attendre - &agrave; ce qu'il inclue du code &agrave; chaque it&eacute;ration. - Pour cela, il faut utiliser <function>include</function>. - <informalexample> - <programlisting role="php"> -<![CDATA[ -<?php - require('header.inc'); -?> -]]> - </programlisting> - </informalexample> - </para> + <function>require</function> et <function>include</function> + sont identiques, sauf dans leur fa&ccedil;on de g&eacute;rer les erreurs. + <function>include</function> produite une + <link linkend="internal.e-warning">Alerte (warning)</link> tandis + que <function>require</function> g&eacute;n&egrave;re une + <link linkend="internal.e-error">erreur fatale</link>. En + d'autres termes, n'h&eacute;sitez pas &agrave; utiliser + <function>require</function> si vous voulez qu'un fichier + d'inclusion manquant interrompe votre script. + <function>include</function> ne se comporte pas de cette fa&ccedil;on, + et le script continuera son ex&eacute;cution. Assurez vous d'avoir + bien configur&eacute; le <link linkend="ini.include-path">include_path</link> + aussi. + </simpara> <para> - Attention : <function>include</function> et - <function>require</function> ajoutent le contenu du fichier cible - dans le script lui-m&ecirc;me. Elles n'utilisent 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> + <example> + <title>Exemples avec <function>require</function></title> <programlisting role="php"> <![CDATA[ <?php - require ("file.inc?varone=1&amp;vartwo=2"); + require ("file.inc?varone=1&vartwo=2"); /* Ne fonctionne pas. */ $varone = 1; $vartwo = 2; @@ -1071,31 +1081,127 @@ ?> ]]> </programlisting> - </informalexample> + </example> </para> <simpara> - Ne vous laissez pas abuser par le fait que vous pouvez - requ&eacute;rir ou inclure des fichiers via HTTP en - utilisant la fonctionnalit&eacute; de - <link linkend="features.remote-files">gestion des fichiers distants</link> - ce qui est au dessus reste vrai. + Voyez la documentation de la fonction <function>include</function> pour plus + d'exemples. </simpara> + <note> + <simpara> + Avant PHP 4.0.2, ceci s'appliquait : <function>require</function> tentait + de lire le fichier cible, m&ecirc;me si les lignes n'&eacute;taient pas utilis&eacute;es. + Une condition if n'avait aucun effet sur <function>require</function>. Cependant, + si la ligne du <function>require</function> n'est jamais utilis&eacute;e, + le code inclus ne le sera pas non plus. De m&ecirc;me, les boucles n'ont pas + d'effet sur le comportement de <function>require</function>. Bien que le + code contenu dans le fichier subit la boucle, la fonction elle m&ecirc;me + <function>require</function> n'est appel&eacute;e qu'une fois. + </simpara> + </note> + &warn.no-win32-fopen-wrapper; <simpara> - En PHP 3, il est possible d'ex&eacute;cuter une commande - <literal>return</literal> depuis un fichier inclut, 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&eacute; a &eacute;t&eacute; - supprim&eacute;e. Si vous en avez besoin, utilisez plut&ocirc;t - <function>include</function>. + Voir aussi + <function>include</function>, + <function>require_once</function>, + <function>include_once</function>, + <function>eval</function>, + <function>file</function>, + <function>readfile</function>, + <function>virtual</function> et + <link linkend="ini.include-path">include_path</link>. </simpara> </sect1> <sect1 id="function.include"> <title><function>include</function></title> <simpara> - La fonction <function>include</function> inclus et &eacute;value le - fichier sp&eacute;cifi&eacute; en argument. + La fonction <function>include</function> inclus et &eacute;x&eacute;cute + le fichier sp&eacute;cifi&eacute; en argument. + </simpara> + <simpara> + Cette documentation s'applique aussi &agrave; la fonction + <function>require</function>. Les deux structures de + langage sont identiques, hormis dans leur gestion des + erreurs. + <function>include</function> produite une + <link linkend="internal.e-warning">Alerte (warning)</link> tandis + que <function>require</function> g&eacute;n&egrave;re une + <link linkend="internal.e-error">erreur fatale</link>. En + d'autres termes, n'h&eacute;sitez pas &agrave; utiliser + <function>require</function> si vous voulez qu'un fichier + d'inclusion manquant interrompe votre script. + <function>include</function> ne se comporte pas de cette fa&ccedil;on, + et le script continuera son ex&eacute;cution. Assurez vous d'avoir + bien configur&eacute; le <link linkend="ini.include-path">include_path</link> + aussi. + </simpara> + <simpara> + Lorsqu'un fichier est inclus, le code qu'il contient h&eacute;rite + des variables qui existent dans ce + <link linkend="language.variables.scope">contexte</link>. + Toute variable accessible &agrave; la ligne qui r&eacute;alise l'ex&eacute;cution + est aussi accessible dans le fichier inclus. + </simpara> + <para> + <example> + <title>Exemple avec <function>include</function></title> + <programlisting role="php"> +<![CDATA[ +vars.php +<?php + +$couleur = 'verte'; +$fruit = 'pomme'; + +?> + +test.php +<?php + +echo "Une $couleur $fruit"; // Une + +include 'vars.php'; + +echo "Une $color $fruit"; // Une verte pomme + +?> +]]> + </programlisting> + </example> + </para> + <simpara> + Si l'inclusion intervient &agrave; l'int&eacute;rieure d'une fonction, + le code inclus sera alors consid&eacute;r&eacute; comme faisant partie de la + fonction. Cela modifie donc le contexte de variables accessibles. </simpara> + <para> + <example> + <title>Inclusion de fichiers dans une fonction</title> + <programlisting role="php"> +<![CDATA[ +<?php + +function foo() { + global $couleur; + + include 'vars.php'; + + echo "Une $couleur $fruit"; +} + +/* vars.php est dans le contexte de foo() * + * donc $fruit n'est pas dispnibles hors de * + * cette fonction. $couleur l'est, car c'est * + * une variable globale */ + +foo(); // Une verte pomme +echo "Une $couleur $fruit"; // Une verte + +?> +]]> + </programlisting> + </example> + </para> <simpara> Il est important de noter que lorsqu'un fichier est <function>include</function> ou <function>require</function>, @@ -1106,189 +1212,163 @@ <link linkend="language.basic-syntax.phpmode">les balises habituelles de PHP</link>. </simpara> + <simpara> + Si les "<link linkend="ini.allow-url-fopen">URL fopen wrappers</link>" + sont activ&eacute;s dans &php; (ce qui est le cas par d&eacute;faut), + vous pouvez localiser le fichier avec une URL (via HTTP ou + bien avec un gestionnaire adapt&eacute; : voir <xref linkend="wrappers"/> + pour une liste des protocoles), au lieu d'un simple chemin + local. Si le serveur distant interpr&ecirc;te le fichier comme du code + PHP, des variables peuvent &ecirc;tre transmises au serveur distant + via l'URL et la m&eacute;thode GET. Ce n'est pas, &agrave; strictement + parler, la m&ecirc;me chose que d'h&eacute;riter du contexte de variable. + Le fichier inclus est en fait un script ex&eacute;cut&eacute; &agrave; distance, + et son r&eacute;sultat est inclus dans le code courant. + </simpara> + &warn.no-win32-fopen-wrapper; <para> - Cela se produit &agrave; chaque fois que la fonction - <function>include</function> est rencontr&eacute;e. Donc, vous - pouvez utiliser la fonction <function>include</function> - dans une boucle pour inclure un nombre infini de - fois un fichier, ou m&ecirc;me des fichiers diff&eacute;rents. - <informalexample> + <example> + <title>Utiliser <function>include</function> via HTTP</title> <programlisting role="php"> <![CDATA[ <?php -$files = array ('premier.inc', 'second.inc', 'troisieme.inc'); -for ($i = 0; $i < count($files); $i++) { - include $files[$i]; -} + +/* Cet exemple suppose que www.exemple.com est configur pour traiter + * les fichiers .php et non pas les fichiers .txt. De plus, + * 'Work' signifie ici que les variables + * $foo et $bar sont disponibles dans le fichier inclus + */ + +// Ne fonctionne pas : file.txt n'a pas &eacute;t&eacute; trait&eacute; par www.exemple.com comme du PHP +include 'http://www.example.com/file.txt?foo=1&bar=2'; + +// Ne fonctionne pas : le script cherche un fichier nomm&eacute; +// 'file.php?foo=1&bar=2' sur le syst&egrave;me local +include 'file.php?foo=1&bar=2'; + +// R&eacute;ussi +include 'http://www.example.com/file.php?foo=1&bar=2'; + +$foo = 1; +$bar = 2; +include 'file.txt'; // OK. +include 'file.php'; // OK. + ?> ]]> </programlisting> - </informalexample> + </example> + Voir aussi + <link linkend="features.remote-files">travailler avec les fichiers distants</link>, + <function>fopen</function> et + <function>file</function> pour des informations reli&eacute;es. </para> <para> - <function>include</function> diff&egrave;re de - <function>require</function> car le fichier inclus est - r&eacute;-&eacute;valu&eacute;e &agrave; chaque fois que la - commande est ex&eacute;cut&eacute;e, tandis que - <function>require</function> est remplac&eacute;e - par le fichier cible lors de la premi&egrave;re - ex&eacute;cution, que son contenu soit utilis&eacute; - ou non. De plus, cela se fait m&ecirc;me s'il - est plac&eacute; dans une structure conditionnelle, - comme dans un <link linkend="control-structures.if">if</link>). + Comme <function>include</function> et <function>require</function> + sont des structures du langages particuli&egrave;res, vous devez les + placer dans un bloc si ils sont plac&eacute;s dans un bloc conditionnel. </para> <para> - Parceque la fonction <function>include</function> n&eacute;cessite - une construction particuli&egrave;re, vous devez l'inclure dans un - bloc si elle est incluse dans une structure conditionnelle. - <informalexample> + <example> + <title><function>include</function> et les conditions</title> <programlisting role="php"> <![CDATA[ <?php -/* Ceci est faux, et ne fonctionnera pas comme on l'attend. */ +// Ceci est FAUX et &eacute;chouera if ($condition) - include($file); + include $file; else - include($other); -/* Ceci est CORRECT. */ + include $other; + + +// Ceci est CORRECT. if ($condition) { - include($file); + include $file; } else { - include($other); + include $other; } + ?> ]]> </programlisting> - </informalexample> + </example> </para> <simpara> - En PHP 3, il est possible d'ex&eacute;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&eacute; a &eacute;t&eacute; - supprim&eacute;e. Cependant, PHP 4 vous autorise &agrave; - retourner des valeurs d'un fichier inclus. Vous pouvez - traiter <function>include</function> comme une fonction - normale, qui retourne une valeur. Mais cela g&eacute;n&egrave;re - une erreur d'analyse en PHP 3. + Gestion du retour : il est possible d'&eacute;x&eacute;cuter une commande + <function>return</function> dans un fichier inclus pour en + terminer le traitement et retourner au fichier appelant. De plus, + il est possible de retourner des valeurs des fichiers inclus. + vous pouvez prendre et traiter la valeur retourn&eacute;e par la + fonction, comme toute autre fonction. </simpara> - <example> - <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&eacute; dans le m&ecirc;me dossier que le fichier - principal : - <programlisting role="php"> -<![CDATA[ -<?php -echo "Avant le retour<br>\n"; -if (1) { - return 27; -} -echo "Apr&egrave;s le retour <br>\n"; -?> -]]> - </programlisting> - </para> - <para> - On suppose que le fichier <filename>main.html</filename> contient ceci : - <programlisting role="php"> + <note> + <simpara> + En PHP 3, le retourn n'est pas utilisable &agrave; moins que ce + ne soit dans un bloc de fonction, auquel cas le + <function>return</function> s'applique &agrave; une fonction et non + pas au fichier. + </simpara> + </note> + <para> + <example> + <title><function>include</function> et <function>return</function></title> + <programlisting role="php"> <![CDATA[ +return.php <?php -$retval = include ('test.inc'); -echo "Fichier inclus: '$retval'<br>\n"; + +$var = 'PHP'; + +return $var; + ?> -]]> - </programlisting> - </para> - <para> - Lorsque <filename>main.html</filename> est appel&eacute; en PHP 3, - il va g&eacute;n&eacute;rer une erreur d'analyse (parse error) - &agrave; la ligne 2; vous ne pouvez pas vous attendre &agrave; un - retour sur une fonction <function>include</function> en PHP 3. En - PHP 4, cependant,le r&eacute;sultat sera : - <screen> -Avant le retour -Ficher inclus : '27' - </screen> - </para> - <para> - Supposons maintenant que <filename>main.html</filename> a - &eacute;t&eacute; modifi&eacute; et contient maintenant le - code suivant : - <programlisting role="php"> -<![CDATA[ + +noreturn.php <?php - include ('test.inc'); - echo "Retour dans le main.html<br>\n"; + +$var = 'PHP'; + ?> -]]> - </programlisting> - </para> - <para> - En PHP 4, l'affichage sera : - <screen> -Avant le retour -Retour dans le main.html - </screen> - 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&eacute;sultat du fait que la commande - <literal>return</literal> est dans un bloc qui n'est pas une fonction, dans - <filename>test.inc</filename>. Lorsque 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 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&icirc;tront en - HTML tout au d&eacute;but du fichier, et l'analyse du fichier parent ne sera - pas interrompue. Pour cette raison, le code qui est dans le fichier doit - &ecirc;tre plac&eacute; entre - <link linkend="language.basic-syntax.phpmode">les balises habituelles de PHP</link>. - <informalexample> - <programlisting role="php"> -<![CDATA[ + +testreturns.php <?php - include ("file.inc?varone=1&amp;vartwo=2"); /* ne fonctionne pas. */ - $varone = 1; - $vartwo = 2; - include ("file.inc"); - /* $varone et $vartwo sont accessibles dans file.inc */ + +$foo = include 'return.php'; + +echo $foo; // prints 'PHP' + +$bar = include 'noreturn.php'; + +echo $bar; // prints 1 + ?> ]]> - </programlisting> - </informalexample> + </programlisting> + </example> </para> <simpara> - Ne vous laissez pas abuser par le fait que vous pouvez requ&eacute;rir - ou inclure des fichiers via HTTP en utilisant la fonctionnalit&eacute; - de <link linkend="features.remote-files">gestion des fichiers distants - </link> ce qui est au dessus reste vrai. + <literal>$bar</literal> a la valeur de <literal>1</literal> car + l'inclusion &eacute;tait r&eacute;ussie. Notez la diff&eacute;rence entre les deux + exemples ci-dessus. Le premier utilise la commande <function>return</function> + dans le fichier inclus, alors que le second ne le fait pas. + Un autre moyen d'inclure des fichiers dans des variables + est d'utiliser la fonction <function>fopen</function> ou + <function>file</function> ou d'utiliser + <function>include</function> avec les + <link linkend="ref.outcontrol">fonctions de contr&ocirc;le de sortie</link>. </simpara> + <simpara> - Voir aussi + Voir aussi + <function>require</function>, + <function>require_once</function>, + <function>include_once</function>, <function>readfile</function>, - <function>require</function> et - <function>virtual</function>. + <function>virtual</function> et + <link linkend="ini.include-path">include_path</link>. </simpara> - </sect1> + </sect1> <sect1 id="function.require-once"> <title><function>require_once</function></title> <para> @@ -1302,138 +1382,51 @@ variables ou de fonctions, g&eacute;n&eacute;ratrices d'alertes. </para> <para> - Par exemple, si vous cr&eacute;ez les deux fichiers d'inclusion - <literal>utils.inc</literal> et <literal>foolib.inc</literal> - <example> - <title>utils.inc</title> - <programlisting role="php"> -<![CDATA[ -<?php -define(PHPVERSION, floor(phpversion())); -echo "LES GLOBALES SONT SYMPAS\n"; -function goodTea() { - return "Le Earl Grey est d&eacute;licieux!"; -} -?> -]]> - </programlisting> - </example> - <example> - <title>foolib.inc</title> - <programlisting role="php"> -<![CDATA[ -<?php -require ("utils.inc"); -function showVar($var) { - if (PHPVERSION == 4) { - print_r($var); - } else { - dump_var($var); - } -} -// Une s&eacute;rie de fonctions -?> -]]> - </programlisting> - </example> - Puis, vous &eacute;crivez un script <literal>cause_error_require.php</literal> - <example> - <title>cause_error_require.php</title> - <programlisting role="php"> -<![CDATA[ -<?php - require("foolib.inc"); -/* Ceci g&eacute;n&egrave;re une erreur*/ - require("utils.inc"); - $foo = array("1",array("complex","quaternion")); - echo "Ce code requiert utils.inc une deuxi&egrave;me fois, car il est requis \n"; - echo "dans foolib.inc\n"; - echo "Utilisation de GoodTea: ".goodTea()."\n"; - echo "Affichage de foo: \n"; - showvar($foo); -?> -]]> - </programlisting> - </example> - Lorsque vous ex&eacute;cutez le script ci-dessus, le - r&eacute;sultat sera (sous PHP 4.01pl2): - <informalexample> - <programlisting> -GLOBALS ARE NICE -GLOBALS ARE NICE -Fatal error: Cannot redeclare causeerror() in utils.inc on line 5 - </programlisting> - </informalexample> - En modifiant <literal>foolib.inc</literal> et - <literal>cause_errror_require.php</literal> - pour qu'elles utilisent <function>require_once</function> - au lieu de <function>require</function> et ne renommant pas le fichier - en <literal>avoid_error_require_once.php</literal>, on obtient : - <example> - <title>foolib.inc (corrig&eacute;)</title> - <programlisting role="php"> + <function>require_once</function> doit &ecirc;tre utilis&eacute;e dans les cas + o&ugrave; le m&ecirc;me fichier risque d'&ecirc;tre inclus et &eacute;valu&eacute;e plusieurs fois + durant l'ex&eacute;cution d'un script. Vous serez alors sur be used in cases where + the same file might be included and evaluated more than once during a + particular execution of a script, and you want to be sure that it is + included exactly once to avoid problems with function redefinitions, + variable value reassignments, etc. + </para> + <para> + Pour des exemples avec <function>require_once</function> et + <function>include_once</function>, reportez-vous au code + <ulink url="&url.php.pear;">PEAR</ulink> inclut dans les + derni&egrave;res distributions PHP. + </para> + <note> + <para> + <function>require_once</function> a &eacute;t&eacute; ajout&eacute; en PHP 4.0.1pl2 + </para> + </note> + <note> + <para> + Attention, <function>require_once</function> et + <function>include_once</function> sont sensibles &agrave; la casse + sous Windows. + <example> + <title><function>require_once</function> est sensible &agrave; la casse</title> + <programlisting role="php"> <![CDATA[ -<?php - require_once("utils.inc"); - function showVar($var) { -?> +require_once("a.php"); // ceci inclut le fichier a.php +require_once("A.php"); // ceci inclut encore le fichier a.php sous Windows! ]]> - </programlisting> - </example> - <example> - <title>avoid_error_require_once.php</title> - <programlisting role="php"> -<![CDATA[ -<?php - require_once("foolib.inc"); - require_once("utils.inc"); - $foo = array("1",array("complexe","quaternion")); -?> -]]> - </programlisting> - </example> - L'ex&eacute;cution de ce script, sous PHP 4.0.1pl2, donne : - <informalexample> - <programlisting> -LES GLOBALES SONT SYMPA -Ce code requiert utils.inc une deuxi&egrave;me fois, car il est requis -dans foolib.inc -Utilisation de GoodTea: Le Earl Grey est d&eacute;licieux! -Affichage de foo: -Array -( - [0] => 1 - [1] => Array - ( - [0] => complexe - [1] => quaternion - ) -) - </programlisting> - </informalexample> - </para> - <para> - Notez aussi que, de la m&ecirc;me mani&egrave;re que les - pr&eacute;processeurs traitent les <literal>#include</literal>, - cette commande est ex&eacute;cut&eacute;e au moment de la - compilation, c'est-&agrave;-dire lorsque le script est - analys&eacute;e, et avant qu'il soit ex&eacute;cut&eacute;, - et ne doit pas &ecirc;tre utilis&eacute;e pour ins&eacute;rer - des donn&eacute;es dynamiques li&eacute;es &agrave; - l'&eacute;x&eacute;cution. Il vaut alors mieux utiliser - <function>include_once</function> ou <function>include</function>. - </para> - <para> - 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&egrave;re distribution de PHP. - </para> + </programlisting> + </example> + </para> + </note> + &warn.no-win32-fopen-wrapper; <para> - Voir aussi : <function>require</function>, - <function>include</function>, <function>include_once</function>, + Voir aussi + <function>require</function>, + <function>include</function>, + <function>include_once</function>, <function>get_required_files</function>, - <function>get_included_files</function>, <function>readfile</function>, - et <function>virtual</function>. + <function>get_included_files</function>, + <function>readfile</function> et + <function>virtual</function>. </para> </sect1> <sect1 id="function.include-once"> Index: phpdoc-fr/language/expressions.xml diff -u phpdoc-fr/language/expressions.xml:1.8 phpdoc-fr/language/expressions.xml:1.9 --- phpdoc-fr/language/expressions.xml:1.8 Tue Aug 13 22:19:28 2002 +++ phpdoc-fr/language/expressions.xml Mon Feb 3 07:27:11 2003 @@ -1,5 +1,5 @@ <?xml version="1.0" encoding="iso-8859-1"?> -<!-- $Revision: 1.8 $ --> +<!-- $Revision: 1.9 $ --> <chapter id="language.expressions"> <title>Les expressions</title> <simpara> @@ -24,11 +24,13 @@ la fonction suivante : <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function foo () { return 5; } -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -128,9 +130,11 @@ vue&agrave;-dire dans d'autre langage, l'op&eacute;rateur conditionnel ternaire: <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $first ? $second : $third -?&gt; +?> +]]> </programlisting> </informalexample> Si la valeur de la premi&egrave;re sous-expression est vraie @@ -144,7 +148,8 @@ incr&eacute;mentation et le concept des expressions en g&eacute;n&eacute;ral: <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function double($i) { return $i*2; } @@ -162,7 +167,8 @@ $h = $g += 10; /* Tout d'abord, $g est incr&eacute;ment&eacute;e de 10, et donc $g vaut 24. Ensuite, la valeur de $g, (24) est assign&eacute;e &agrave; la variable $h, qui vaut donc elle aussi 24. */ -?&gt; +?> +]]> </programlisting> </informalexample> </para> Index: phpdoc-fr/language/functions.xml diff -u phpdoc-fr/language/functions.xml:1.11 phpdoc-fr/language/functions.xml:1.12 --- phpdoc-fr/language/functions.xml:1.11 Wed Dec 12 15:50:07 2001 +++ phpdoc-fr/language/functions.xml Mon Feb 3 07:27:11 2003 @@ -1,6 +1,6 @@ <?xml version="1.0" encoding="iso-8859-1"?> -<!-- $Revision: 1.11 $ --> - <chapter id="function"> +<!-- $Revision: 1.12 $ --> + <chapter id="functions"> <title>Les fonctions</title> <sect1 id="functions.user-defined"> <title>Les fonctions utilisateur</title> @@ -8,12 +8,14 @@ Une fonction peut &ecirc;tre d&eacute;finie en utilisant la syntaxe suivante : <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function foo ($arg_1, $arg_2, ..., $arg_n) { echo "Exemple de fonction.\n"; return $retval; } -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -62,11 +64,13 @@ un tableau comme argument : <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function takes_array($input) { echo "$input[0] + $input[1] = ", $input[0]+$input[1]; } -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -87,14 +91,16 @@ devant l'argument dans la d&eacute;claration de la fonction : <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function add_some_extra(&amp;$string) { $string .= ', et un peu plus.'; } $str = 'Ceci est une cha&icirc;ne'; add_some_extra($str); echo $str; // affiche 'Ceci est une cha&icirc;ne, et un peu plus.' -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -105,7 +111,8 @@ devant l'argument dans l'appel de la fonction: <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function foo ($bar) { $bar .= ', et un peu plus.'; } @@ -114,7 +121,8 @@ echo $str; // affiche 'Ceci est une cha&icirc;ne' foo (&amp;$str); echo $str; // affiche 'Ceci est une cha&icirc;ne, et un peu plus.' -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -126,13 +134,15 @@ d&eacute;faut pour les arguments de type scalaire : <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function servir_apero ($type = "ricard") { return "Servir un verre de $type.\n"; } echo servir_apero(); echo servir_apero("whisky"); -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -156,12 +166,14 @@ Consid&eacute;rons le code suivant : <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function faireunyaourt ($type = "acidophilus", $flavour) { return "Pr&eacute;parer un bol de $type $flavour.\n"; } echo faireunyaourt ("framboise"); // ne fonctionne pas comme voulu -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -178,12 +190,14 @@ l'exemple suivant : <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function faireunyaourt ($flavour, $type = "acidophilus") { return "Pr&eacute;parer un bol de $type $flavour.\n"; } echo faireunyaourt ("framboise"); // fonctionne comme voulu -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -218,12 +232,14 @@ peuvent &ecirc;tre renvoy&eacute;s, tableaux et objets compris. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function carre ($num) { return $num * $num; } echo carre (4); // affiche '16'. -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -233,12 +249,14 @@ en renvoyant un tableau. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function petit_nombre() { return array (0, 1, 2); } list ($zero, $one, $two) = petit_nombre(); -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -248,12 +266,14 @@ l'assignation de la valeur de retour. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function &amp;retourne_reference() { return $uneref; } $newref =&amp;retourne_reference(); -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -303,7 +323,8 @@ <example> <title>Exemple de fonction variable</title> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function foo() { echo "dans foo()&lt;br&gt;\n"; } @@ -314,7 +335,8 @@ $func(); $func = 'bar'; $func( 'test' ); -?&gt; +?> +]]> </programlisting> </example> </para> Index: phpdoc-fr/language/oop.xml diff -u phpdoc-fr/language/oop.xml:1.18 phpdoc-fr/language/oop.xml:1.19 --- phpdoc-fr/language/oop.xml:1.18 Tue Aug 13 22:19:28 2002 +++ phpdoc-fr/language/oop.xml Mon Feb 3 07:27:11 2003 @@ -1,5 +1,5 @@ <?xml version="1.0" encoding="iso-8859-1"?> -<!-- $Revision: 1.18 $ --> +<!-- $Revision: 1.19 $ --> <chapter id="language.oop"> <title>Les classes et les objets</title> <sect1 id="keyword.class"> @@ -10,24 +10,29 @@ en utilisant la syntaxe suivante : <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php class Caddie { - var $items; // El&eacute;ments de notre panier - // Ajout de $num articles de type $artnr au panier +// El&eacute;ments de notre panier + var $items; + +// 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 + +// Suppression de $num articles du type $artnr du panier function remove_item ($artnr, $num) { - if ($this->items[$artnr] &gt; $num) { + if ($this->items[$artnr] > $num) { $this->items[$artnr] -= $num; return &true;; } else { - return <literal>FALSE</literal>; + return FALSE; } } } -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -69,7 +74,8 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php /* Aucune de ces syntaxes ne fonctionnera en PHP 4 */ class Caddie { var $date_du_jour = date("d/m/Y"); @@ -89,7 +95,8 @@ /* etc... */ } } -?&gt; +?> +]]> </programlisting> </informalexample> </note> @@ -99,12 +106,15 @@ </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php $cart = new Caddie; $cart->add_item("10", 1); $another_cart = new Cart; $another_cart->add_item("0815", 3); -?&gt; +?> +]]> + </programlisting> </informalexample> <para> @@ -131,8 +141,9 @@ </para> <informalexample> <programlisting role="php"> -&lt;?php -// correct, $ unique + <![CDATA[ +<?php +// correct, le signe $ est unique $cart->items = array("10" => 1); // incorrect, car $cart->$items devient $cart->"" $cart->$items = array("10" => 1); @@ -140,7 +151,8 @@ // $cart->$myvar devient $ncart->items $myvar = 'items'; $cart->$myvar = array("10" => 1); -?&gt; +?> +]]> </programlisting> </informalexample> <para> @@ -174,34 +186,38 @@ </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php class Caddie_nomme extends Caddie { var $owner; function set_owner ($name) { $this->owner = $name; } } -?&gt; +?> +]]> </programlisting> </informalexample> <para> L'exemple ci-desssus d&eacute;finit la classe Caddie_nomme qui - poss&egrave;de les m&ecirc;me variables que la classe Caddie et + poss&egrave;de les m&ecirc;mes variables que la classe Caddie et la variable $owner en plus, ainsi que la fonction set_owner(). Vous cr&eacute;ez un panier nominatif de la m&ecirc;me mani&egrave;re que pr&eacute;c&eacute;demment, et vous pouvez alors affecter un nom au panier ou en conna&icirc;tre le nom. Vous pouvez de - toutes les fa&ccedil;ons utiliser les m&ecirc;me fonctions que sur un + toutes les fa&ccedil;ons utiliser les m&ecirc;mes fonctions que sur un panier classique. </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php $ncart = new Caddie_nomme; // Cr&eacute;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&eacute;ritage des fonctions de la classe p&egrave;re) -?&gt; +?> +]]> </programlisting> </informalexample> </sect1> @@ -221,19 +237,21 @@ le m&ecirc;me nom que la classe. En PHP 3, une fonction devient le constructeur si elle porte le m&ecirc;me nom que la classe. En PHP 4, une fonction devient un constructeur - si elle porte le m&ecirc;me nom que la classe dans laquelle elle est d&eacute;finit. + si elle porte le m&ecirc;me nom que la classe dans laquelle elle est d&eacute;finie. La diff&eacute;rence est subtile, mais cruciale. </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php class Auto_Caddie extends Caddie { function Auto_Caddie () { $this->add_item ("10", 1); } } // Cette syntaxe est valable en PHP 3 et 4 -?&gt; +?> +]]> </programlisting> </informalexample> <para> @@ -249,7 +267,8 @@ </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php // Cette syntaxe est valable en PHP 3 et 4 class Constructor_Cart extends Cart { function Constructor_Cart ($item = "10", $num = 1) { @@ -260,7 +279,8 @@ $default_cart = new Constructor_Cart; // Cr&eacute;ation d'un vrai caddie $different_cart = new Constructor_Cart ("20", 17); -?&gt; +?> +]]> </programlisting> </informalexample> <caution> @@ -272,25 +292,27 @@ </caution> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php class A { function A() { - echo "Je suis le constructeur de A.&lt;br&gt;\n"; + echo "Je suis le constructeur de A.<br>\n"; } } class B extends A { function C() { - "Je suis une fonction standard.&lt;br&gt;\n"; + "Je suis une fonction standard.<br>\n"; } } // Aucun constructeur n'est appel&eacute; en PHP 3!! $b = new B; -?&gt; +?> +]]> </programlisting> </informalexample> <para> En PHP 3, aucun constructeur ne sera appel&eacute; dans l'exemple ci-dessus. - La r&egrave;gle en PHP 3 est : 'Un constructeur est une fonction qui a le m&ecirc;me nom + La r&egrave;gle en PHP 3 est : 'Un constructeur est une m&eacute;thode qui a le m&ecirc;me nom que la classe'. Le nom de la classe est B, et il n'y a pas de fonctions qui s'appelle B() dans la classe B. Rien ne se passe. </para> @@ -302,40 +324,42 @@ </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php class A { function A() { - echo "Je suis le constructeur de A.&lt;br&gt;\n"; + echo "Je suis le constructeur de A.<br>\n"; } function B() { - echo "Je suis une fonction standard appel&eacute;e B dans la classe A.&lt;br&gt;\n"; - echo "Je ne suis pas le constructeur de A.&lt;br&gt;\n"; + echo "Je suis une fonction standard appel&eacute;e B dans la classe A.<br>\n"; + echo "Je ne suis pas le constructeur de A.<br>\n"; } } class B extends A { function C() { - echo "Je suis une fonction standard.&lt;br&gt;\n"; + echo "Je suis une fonction standard.<br>\n"; } } // Cette syntaxe va appeler B() comme constructeur. $b = new B; -?&gt; +?> +]]> </programlisting> </informalexample> <para> En PHP 3, la fonction B() de la classe A va soudaiement devenir le constructeur de la classe B, bien qu'il n'ai pas &eacute;t&eacute; pr&eacute;vu pour. La r&egrave;gle de PHP 3 est 'Un constructeur est une - fonction qui a le m&ecirc;me nom que la classe'. PHP 3 ne se soucie + m&eacute;thode qui a le m&ecirc;me nom que la classe'. PHP 3 ne se soucie gu&egrave;re si la fonction est d&eacute;finie dans la classe B ou si elle a &eacute;t&eacute; h&eacute;rit&eacute;e. </para> <para> Ceci est corrig&eacute; en PHP 4, avec l'introduction d'une nouvelle r&egrave;gle : - 'Un constructeur est une classe de m&ecirc;me nom, d&eacute;finit dans la - classe elle-m&ecirc;me'. Donc, en PHP 4, la classe B n'a pas de constructeur + 'Un constructeur est une m&eacute;thode de m&ecirc;me nom que la classe, d&eacute;finie + dans la classe elle-m&ecirc;me'. Donc, en PHP 4, la classe B n'a pas de constructeur par elle-m&ecirc;me, et le constructeur de la classe A aura &eacute;t&eacute; appel&eacute;, affichant : 'Je suis le constructeur de A.&lt;br&gt;'. @@ -378,29 +402,31 @@ </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php class A { function example() { - echo "Je suis la fonction originale A::example().&lt;br&gt;\n"; + echo "Je suis la fonction originale A::example().<br>\n"; } } class B extends A { function example() { - echo "Je suis la fonction red&eacute;finie B::example().&lt;br&gt;\n"; + echo "Je suis la fonction red&eacute;finie B::example().<br>\n"; A::example(); } } // Il n'y a pas d'objets de classe A. // L'affichage est : -// Je suis la fonction originale A::example().&lt;br&gt; +// Je suis la fonction originale A::example().<br> A::example(); // Cr&eacute;ation d'un objet de la classe B. $b = new B; // L'affichage est : -// Je suis la fonction red&eacute;finie B::example().&lt;br&gt; -// Je suis la fonction originale A::example().&lt;br&gt; +// Je suis la fonction red&eacute;finie B::example().<br> +// Je suis la fonction originale A::example().<br> $b->example(); -?&gt; +?> +]]> </programlisting> </informalexample> <para> @@ -452,22 +478,24 @@ </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php class A { function example() { - echo "Je suis A::example() et je fournis une fonctionnalit&eacute; de base.&lt;br&gt;\n"; + echo "Je suis A::example() et je fournis une fonctionnalit&eacute; de base.<br>\n"; } } class B extends A { function example() { - echo "Je suis B::example() et je fournis une fonctionnalit&eacute; suppl&eacute;mentaire.&lt;br&gt;\n"; + echo "Je suis B::example() et je fournis une fonctionnalit&eacute; suppl&eacute;mentaire.<br>\n"; parent::example(); } } $b = new B; // Cette syntaxe va appeler B::example(), qui, &agrave; sont tour, va appeler A::example(). $b->example(); -?&gt; +?> +]]> </programlisting> </informalexample> </sect1> @@ -510,7 +538,8 @@ </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php classa.inc: class A { var $one = 1; @@ -518,9 +547,9 @@ echo $this->one; } } -?&gt; +?> page1.php: -&lt;?php +<?php include("classa.inc"); $a = new A; $s = serialize($a); @@ -528,16 +557,17 @@ $fp = fopen("store", "w"); fputs($fp, $s); fclose($fp); -?&gt; +?> page2.php: -&lt;?php +<?php // Ceci est n&eacute;cessaire pour que unserialize() fonctionne correctement include("classa.inc"); $s = implode("", @file("store")); unserialize($s); // maintenant, utilisez la m&eacute;thode show_one de l'objet $a. $a->show_one(); -?&gt; +?> +]]> </programlisting> </informalexample> <para> @@ -590,7 +620,7 @@ variables qui n'ont pas &eacute;t&eacute; sauv&eacute;es. </para> </sect1> - <sect1 id="keyword.newref"> + <sect1 id="language.oop.newref"> <title>R&eacute;f&eacute;rences dans un constructeur</title> <para> Cr&eacute;er des r&eacute;f&eacute;rences dans un constructeur peut conduire &agrave; @@ -598,25 +628,27 @@ probl&egrave;mes. <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php class foo { function foo($name) { // cr&eacute;e une r&eacute;f&eacute;rence dans le tableau global $globalref global $globalref; - $globalref[] = &amp;$this; + $globalref[] = &$this; // donne le nom de la variable - $this-&gt;setName($name); + $this->setName($name); // et l'affiche - $this-&gt;echoName(); + $this->echoName(); } function echoName() { - echo "&lt;br&gt;",$this-&gt;Name; + echo "<br>",$this->Name; } function setName($name) { - $this-&gt;Name = $name; + $this->Name = $name; } } -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -627,22 +659,24 @@ </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php $bar1 = new foo('cr&eacute;e dans le constructeur'); - $bar1-&gt;echoName(); - $globalref[0]-&gt;echoName(); + $bar1->echoName(); + $globalref[0]->echoName(); /* affiche : cr&eacute;e dans le constructeur cr&eacute;e dans le constructeur cr&eacute;e dans le constructeur */ $bar2 =&amp;new foo('cr&eacute;e dans le constructeur'); - $bar2-&gt;echoName(); - $globalref[1]-&gt;echoName(); + $bar2->echoName(); + $globalref[1]->echoName(); /* affiche : cr&eacute;e dans le constructeur cr&eacute;e dans le constructeur cr&eacute;e dans le constructeur */ -?&gt; +?> +]]> </programlisting> </informalexample> <para> @@ -666,69 +700,72 @@ </para> <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php // maintenant, nous allons changer de nom. Qu'attendez-vous? // Vous pouvez vous attendre &agrave; ce que les deux variables $bar // et $globalref[0] changent de nom... - $bar1-&gt;setName('modifi&eacute;'); + $bar1->setName('modifi&eacute;'); // comme pr&eacute;dit, ce n'est pas le cas - $bar1-&gt;echoName(); - $globalref[0]-&gt;echoName(); + $bar1->echoName(); + $globalref[0]->echoName(); /* affiche : cr&eacute;e dans le constructeur modifi&eacute; */ // quelle est la diff&eacute;rence entre $bar2 et $globalref[1] - $bar2-&gt;setName('modifi&eacute;'); + $bar2->setName('modifi&eacute;'); // Heureusement, elles sont non seulement &eacute;gales, mais // elles repr&eacute;sentent la m&ecirc;me variable. - // donc $bar2-&gt;Name et $globalref[1]-&gt;Name sont les m&ecirc;mes - $bar2-&gt;echoName(); - $globalref[1]-&gt;echoName(); + // donc $bar2->Name et $globalref[1]->Name sont les m&ecirc;mes + $bar2->echoName(); + $globalref[1]->echoName(); /* affiche : modifi&eacute; modifi&eacute; */ -?&gt; +?> +]]> </programlisting> </informalexample> <para> Un dernier exemple pour bien comprendre. <informalexample> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php class a { function a($i) { - $this-&gt;value = $i; + $this->value = $i; // Essayez de comprendre on n'a pas besoin de // r&eacute;f&eacute;rence ici - $this-&gt;b = new b($this); + $this->b = new b($this); } function createRef() { - $this-&gt;c = new b($this); + $this->c = new b($this); } function echoValue() { - echo "&lt;br&gt;","class ",get_class($this),': ',$this-&gt;value; + echo "<br>","class ",get_class($this),': ',$this->value; } } class b { function b(&amp;$a) { - $this-&gt;a = &amp;$a; + $this->a = &amp;$a; } function echoValue() { - echo "&lt;br&gt;","class ",get_class($this),': ',$this-&gt;a-&gt;value; + echo "<br>","class ",get_class($this),': ',$this->a->value; } } // Essayez de comprendre pourquoi une copie simple va // conduire &agrave; un r&eacute;sultat ind&eacute;sirable &agrave; // la ligne marqu&eacute;e d'une &eacute;toile $a =&amp;new a(10); -$a-&gt;createRef(); -$a-&gt;echoValue(); -$a-&gt;b-&gt;echoValue(); -$a-&gt;c-&gt;echoValue(); -$a-&gt;value = 11; -$a-&gt;echoValue(); -$a-&gt;b-&gt;echoValue(); // * -$a-&gt;c-&gt;echoValue(); +$a->createRef(); +$a->echoValue(); +$a->b->echoValue(); +$a->c->echoValue(); +$a->value = 11; +$a->echoValue(); +$a->b->echoValue(); // * +$a->c->echoValue(); /* output: class a: 10 @@ -738,7 +775,9 @@ class b: 11 class b: 11 */ -?&gt; +?> +]]> + </programlisting> </informalexample> </para> Index: phpdoc-fr/language/operators.xml diff -u phpdoc-fr/language/operators.xml:1.18 phpdoc-fr/language/operators.xml:1.19 --- phpdoc-fr/language/operators.xml:1.18 Fri Jun 28 13:36:36 2002 +++ phpdoc-fr/language/operators.xml Mon Feb 3 07:27:11 2003 @@ -1,5 +1,5 @@ <?xml version="1.0" encoding="iso-8859-1"?> -<!-- $Revision: 1.18 $ --> +<!-- $Revision: 1.19 $ --> <chapter id="language.operators"> <title>Les op&eacute;rateurs</title> <simpara> @@ -112,6 +112,15 @@ </tgroup> </table> </para> + <note> + <para> + Bien que <literal>!</literal> soit prioritaire sur + <literal>=</literal>, &php; va tout de m&ecirc;me ex&eacute;cuter des + expressions comme : <literal>if (!$a = foo())</literal>. + Dans cette situation, le r&eacute;sultat de <literal>foo()</literal> + sera plac&eacute; dans la variable <varname>$a</varname>. + </para> + </note> </sect1> <sect1 id="language.operators.arithmetic"> <title>Les op&eacute;rateurs arithm&eacute;tiques</title> @@ -452,7 +461,7 @@ <![CDATA[ <?php $output = `ls -al`; - echo "&lt;pre&gt;$output&lt;/pre&gt;"; + echo "<pre>$output</pre>"; ?> ]]> </programlisting> @@ -461,7 +470,7 @@ <note> <para> Cet op&eacute;rateur est d&eacute;sactiv&eacute; lorsque le - <link linkend="ini.safe-mode">safe mode</link> est activ&eacute;. + &safemode; est activ&eacute;. </para> </note> <para> @@ -514,27 +523,27 @@ </tgroup> </table> <para> - Voici un exempla simple + Voici un exemple simple <informalexample> <programlisting role="php"> <![CDATA[ <?php - echo "&lt;h3&gt;Post-incr&eacute;mentation&lt;/h3&gt;"; + echo "<h3>Post-incr&eacute;mentation</h3>"; $a = 5; - echo "Devrait valoir 5: " . $a++ . "&lt;br&gt;\n"; - echo "Devrait valoir 6: " . $a . "&lt;br&gt;\n"; - echo "&lt;h3&gt;Pr&eacute;-incr&eacute;mentation&lt;/h3&gt;"; + echo "Devrait valoir 5: " . $a++ . "<br>\n"; + echo "Devrait valoir 6: " . $a . "<br>\n"; + echo "<h3>Pr&eacute;-incr&eacute;mentation</h3>"; $a = 5; - echo "Devrait valoir 6: " . ++$a . "&lt;br&gt;\n"; - echo "Devrait valoir 6: " . $a . "&lt;br&gt;\n"; - echo "&lt;h3&gt;Post-d&eacute;cr&eacute;mentation&lt;/h3&gt;"; + echo "Devrait valoir 6: " . ++$a . "<br>\n"; + echo "Devrait valoir 6: " . $a . "<br>\n"; + echo "<h3>Post-d&eacute;cr&eacute;mentation</h3>"; $a = 5; - echo "Devrait valoir 5: " . $a-- . "&lt;br&gt;\n"; - echo "Devrait valoir 4: " . $a . "&lt;br&gt;\n"; - echo "&lt;h3&gt;Pr&eacute;-d&eacute;cr&eacute;mentation&lt;/h3&gt;"; + echo "Devrait valoir 5: " . $a-- . "<br>\n"; + echo "Devrait valoir 4: " . $a . "<br>\n"; + echo "<h3>Pr&eacute;-d&eacute;cr&eacute;mentation</h3>"; $a = 5; - echo "Devrait valoir 4: " . --$a . "&lt;br&gt;\n"; - echo "Devrait valoir 4: " . $a . "&lt;br&gt;\n"; + echo "Devrait valoir 4: " . --$a . "<br>\n"; + echo "Devrait valoir 4: " . $a . "<br>\n"; ?> ]]> </programlisting> @@ -602,8 +611,8 @@ est l'op&eacute;rateur de concat&eacute;nation ('.'), qui retourne la concat&eacute;nation de ses deux arguments. Le second est l'op&eacute;rateur d'assignation - concat&eacute;nant ('.='). Reportez-vous &agrave; - <link linkend="language.operators.assignment">Op&eacute;rateurs d'assignations</link> + concat&eacute;nant (<literal>.=</literal>). Reportez-vous &agrave; + <link linkend="language.operators.assignment">op&eacute;rateurs d'assignement</link> pour plus de d&eacute;tails. </simpara> <para> @@ -621,6 +630,43 @@ ]]> </programlisting> </informalexample> + </para> + </sect1> + <sect1 id="language.operators.array"> + <title>Op&eacute;rateurs de tableaux</title> + <simpara> + Le seul op&eacute;rateur en &php; pour les tableaux est l'op&eacute;rateur + <literal>+</literal>. Cet op&eacute;rateur ajoute le tableau de + droite au tableau de gauche. Les cl&eacute;s communes sont laiss&eacute;es + inchang&eacute;es. + </simpara> + <para> + <example> + <title>Addition de tableaux</title> + <programlisting role="php"> +<![CDATA[ +$a = array("a" => "pomme", "b" => "banane"); +$b = array("a" =>"poire", "b" => "fraise", "c" => "cerise"); + +$c = $a + $b; + +var_dump($c); +]]> + </programlisting> + <screen role="php"> +<![CDATA[ +array(3) { + ["a"]=> + string(5) "pomme" + ["b"]=> + string(6) "banane" + ["c"]=> + string(6) "cerise" +} + +]]> + </screen> + </example> </para> </sect1> </chapter> Index: phpdoc-fr/language/references.xml diff -u phpdoc-fr/language/references.xml:1.8 phpdoc-fr/language/references.xml:1.9 --- phpdoc-fr/language/references.xml:1.8 Wed Dec 12 15:50:08 2001 +++ phpdoc-fr/language/references.xml Mon Feb 3 07:27:11 2003 @@ -1,5 +1,5 @@ <?xml version="1.0" encoding="iso-8859-1"?> -<!-- $Revision: 1.8 $ --> +<!-- $Revision: 1.9 $ --> <chapter id="language.references"> <title>Les r&eacute;f&eacute;rences</title> <sect1 id="language.references.whatare"> @@ -26,9 +26,11 @@ vous faites : <informalexample> <programlisting role="php"> -&lt;?php -$a =&amp; $b -?&gt; +<![CDATA[ +<?php +$a =& $b +?> +]]> </programlisting> </informalexample> cela signifie que <varname>$a</varname> et <varname>$b</varname> @@ -46,10 +48,12 @@ <literal>new</literal> (PHP 4.0.4 et plus r&eacute;cent): <informalexample> <programlisting role="php"> -&lt;?php - $bar =&amp; new fooclass(); - $foo =&amp; find_var ($bar); -?&gt; +<![CDATA[ +<?php + $bar =& new fooclass(); + $foo =& find_var ($bar); +?> +]]> </programlisting> </informalexample> </para> @@ -70,13 +74,15 @@ le contenu des variables de fonction. Exemple : <informalexample> <programlisting role="php"> -&lt;?php - function foo(&amp;$var) { +<![CDATA[ +<?php + function foo(&$var) { $var++; } $a=5; foo($a); -?&gt; +?> +]]> </programlisting> </informalexample> <varname>$a</varname> vaut 6. Cela provient du fait que dans la fonction @@ -100,12 +106,14 @@ ce &agrave; quoi on peut s'attendre : <informalexample> <programlisting role="php"> -&lt;?php - function foo(&amp;$var) { - $var =&amp; $GLOBALS["baz"]; +<![CDATA[ +<?php + function foo(&$var) { + $var =& $GLOBALS["baz"]; } foo($bar); -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -129,14 +137,16 @@ syntaxe est la suivante : <informalexample> <programlisting role="php"> -&lt;?php - function foo(&amp;$var) { +<![CDATA[ +<?php + function foo(&$var) { $var++; } $a=5; foo ($a); // $a vaut 6 maintenant -?&gt; +?> +]]> </programlisting> </informalexample> Notez qu'il n'y a pas de signe de r&eacute;f&eacute;rence dans l'appel de la @@ -163,13 +173,15 @@ Une r&eacute;f&eacute;rence, retourn&eacute;e par une fonction : <informalexample> <programlisting role="php"> -&lt;?php - function &amp;bar() { +<![CDATA[ +<?php + function &bar() { $a = 5; return $a; } foo(bar()); -?&gt; +?> +]]> </programlisting> </informalexample> Voir aussi des d&eacute;tails dans @@ -185,8 +197,9 @@ exemple, les passages par r&eacute;f&eacute;rence suivants sont invalides : <informalexample> <programlisting role="php"> -&lt;?php - function bar() // Notez l'absence de &amp; +<![CDATA[ +<?php + function bar() // Notez l'absence de & { $a = 5; return $a; @@ -194,7 +207,8 @@ foo(bar); foo($a = 5) // Expression, pas une variable foo(5) // Constante, pas une variable -?&gt; +?> +]]> </programlisting> </informalexample> Ces fonctionnalit&eacute;s sont valables &agrave; partir de PHP 4.0.4. @@ -209,14 +223,16 @@ utilisez le code suivant <informalexample> <programlisting role="php"> -&lt;?php - function &amp;find_var($param) { +<![CDATA[ +<?php + function &find_var($param) { // ...code... return $found_var; } - $foo =&amp; find_var ($bar); - $foo-&gt;x = 2; -?&gt; + $foo =& find_var ($bar); + $foo->x = 2; +?> +]]> </programlisting> </informalexample> Dans cet exemple, la propri&eacute;t&eacute; de l'objet est retourn&eacute;e @@ -242,11 +258,13 @@ Cela ne signifie pas que le contenu est d&eacute;truit. Par exemple, <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $a = 1; -$b =&amp; $a; +$b =& $a; unset ($a); -?&gt; +?> +]]> </programlisting> </informalexample> Cet exemple ne d&eacute;truira pas <varname>$b</varname>, mais juste @@ -275,9 +293,11 @@ globale. Ce qui signifie que <informalexample> <programlisting role="php"> -&lt;?php -$var =&amp; $GLOBALS["var"]; -?&gt; +<![CDATA[ +<?php +$var =& $GLOBALS["var"]; +?> +]]> </programlisting> </informalexample> </para> Index: phpdoc-fr/language/types.xml diff -u phpdoc-fr/language/types.xml:1.19 phpdoc-fr/language/types.xml:1.20 --- phpdoc-fr/language/types.xml:1.19 Tue Aug 13 22:19:28 2002 +++ phpdoc-fr/language/types.xml Mon Feb 3 07:27:11 2003 @@ -1,5 +1,5 @@ <?xml version="1.0" encoding="iso-8859-1"?> -<!-- $Revision: 1.19 $ --> +<!-- $Revision: 1.20 $ --> <chapter id="language.types"> <title>Les types</title> <sect1 id="language.types.intro"> @@ -104,46 +104,52 @@ <title>Bool&eacute;ens</title> <simpara> C'est le type le plus simple. Un bool&eacute;en exprime les valeurs - de vrai &true; ou <literal>FALSE</literal>. + de vrai &true; ou &false;. </simpara> - <para> + <sect2 id="language.types.boolean.syntax"> + <title>Syntaxe</title> + <para> Vous pouvez utiliser les constantes '&true;' et - '<literal>FALSE</literal>' pour sp&eacute;cifier une valeur de type - <type>boolean</type>. G&eacute;n&eacute;ralement, vous les cr&eacute;erez - avec un des <link linkend="language.operators">operateurs</link> + '&false;' pour sp&eacute;cifier une valeur de type + <type>boolean</type>. Ces constantes sont insensibles + &agrave; la casse. + <informalexample> + <programlisting role="php"> +<![CDATA[ +$foo = True; // assign the value TRUE to $foo +]]> + </programlisting> + </informalexample> + </para> + <para> + G&eacute;n&eacute;ralement, vous les cr&eacute;erez + avec un des <link linkend="language.operators">op&eacute;rateurs</link> qui retourne une valeur <type>boolean</type>, pour le passer - &agrave; une <link linkend="control-structures">structure de - contr&ocirc;le</link>. + &agrave; une <link linkend="control-structures">structure de contr&ocirc;le</link>. <informalexample> <programlisting role="php"> -&lt;?php - if ($action == "show_version"){ -// == is an <link linkend="language.operators">operator</link> +<![CDATA[ +// == est un op&eacute;rateur d'&eacute;galit&eacute; // qui retourne un bool&eacute;en - echo "La version est 1.23"; - } -// ceci n'est pas n&eacute;cessaire - if ($show_separators == true){ - echo "&lt;hr&gt;\n"; - } -// ceci est plus pratique - if ($show_separators){ - echo "&lt;hr&gt;\n"; - } -?&gt; +if ($action == "show_version") { + echo "La version est la 1.23"; +} + +// Ceci n'est pas n&eacute;cessaire +if ($show_separators == TRUE) { + echo "<hr>\n"; +} + +// car vous pouvez simplement utiliser +if ($show_separators) { + echo "<hr>\n"; +} +]]> </programlisting> </informalexample> - </para> - <!-- TODO: example of this --> - <!-- TODO: example to show that if ( expr == TRUE ) is not really - necessary... (i've seen this construct numerous times) - --> - <!-- TODO: how others vars are converted to boolean --> - <note> - <simpara> - Le type boo&eacute;en a &eacute;t&eacute; introduit en PHP 4. - </simpara> - </note> + </para> + </sect2> + <sect2 id="language.types.boolean.casting"> <title>Conversion en bool&eacute;en</title> <simpara> @@ -153,7 +159,7 @@ </simpara> <para> Lors des conversions de valeurs de type <type>boolean</type>, les valeurs - suivantes sont consid&eacute;r&eacute;es comme fausse (<literal>FALSE</literal>) : + suivantes sont consid&eacute;r&eacute;es comme fausse (&false;) : <itemizedlist> <listitem> <simpara> @@ -216,33 +222,55 @@ &eacute;ventuellement pr&eacute;c&eacute;d&eacute; du signe moins (<literal>-</literal>). </para> - <para> + <sect2 id="language.types.integer.syntax"> + <title>Syntax</title> + <simpara> + Les entiers peuvent &ecirc;tre sp&eacute;cifi&eacute; en base d&eacute;cimale (dite aussi + base 10), en h&eacute;xadecimal (base 16) ou en octale (base 8). + Les entiers peuvent &ecirc;tre optionnellement pr&eacute;c&eacute;d&eacute;s par le signe + plus ou moins (- or +). + </simpara> + <para> Pour utiliser la notation octale, vous devez pr&eacute;fixer le nombre avec un z&eacute;ro; pour utiliser la notation hexad&eacute;cimale, vous devez pr&eacute;fixer le nombre avec <literal>0x</literal>. - <informalexample> - <programlisting role="php"> -&lt;?php - $a = 1234; # nombre entier en base 10 - $a = -123; # nombre entier n&eacute;gatif - $a = 0123; # nombre entier en base 8, octale (&eacute;quivalent &agrave; 83 en base 10) - $a = 0x12; # nombre entier en base 16, hexad&eacute;cimale - # (&eacute;quivalent &agrave; 18 en base 10) -?&gt; - </programlisting> - </informalexample> - La taille des entiers d&eacute;pend de la plate-forme de support, mais + <example> + <title>Integer literals</title> + <programlisting role="php"> +<![CDATA[ +$a = 1234; // nombre entier en base 10 +$a = -123; // nombre entier n&eacute;gatif +$a = 0123; // nombre entier en base 8, octale (&eacute;quivalent &agrave; 83 en base 10) +$a = 0x1A; // nombre entier en base 16, hexad&eacute;cimale + // (&eacute;quivalent &agrave; 26 en base 10) +]]> + </programlisting> + </example> + Techniquement, la structure d'un entier suit les r&egrave;gles suivantes : + <example> + <title>Structure d'un entier</title> + <programlisting> +<![CDATA[ +decimal : [1-9][0-9]* + | 0 + +hexadecimal : 0[xX][0-9a-fA-F]+ + +octal : 0[0-7]+ + +integer : [+-]?decimal + | [+-]?hexadecimal + | [+-]?octal +]]> + </programlisting> + </example> + La taille des entiers d&eacute;pend de la plate-forme de support, mais la valeur maximale est g&eacute;n&eacute;ralement de 2 milliards et des poussi&egrave;res (c'est un entier sign&eacute; de 32 bits). PHP ne supporte pas les entiers non sign&eacute;s. - </para> - <note> - <simpara> - En PHP, il n'existe pas de type fraction. - <literal>1/2</literal> se transforme en nombre &agrave; virgule - flottante <literal>0.5</literal>. - </simpara> - </note> + </para> + </sect2> + <sect2 id="language.types.integer.overflow"> <title>D&eacute;passement de capacit&eacute; des entiers</title> <para> @@ -250,7 +278,8 @@ des entiers, il sera interpr&eacute;t&eacute; comme un <type>float</type>. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $large_number = 2147483647; var_dump($large_number); // affiche : int(2147483647) @@ -260,7 +289,8 @@ var_dump( 25/7 ); // affiche : float(3.5714285714286) -?&gt; +?> +]]> </programlisting> </informalexample> De m&ecirc;me, si une fonction ou un op&eacute;rateur retourne un entier qui @@ -268,12 +298,14 @@ automatiquement converti en <type>float</type>. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $million = 1000000; $large_number = 50000 * $million; var_dump($large_number); // affiche : float(50000000000) -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -298,7 +330,7 @@ <sect2 id="language.types.integer.casting"> <title>Conversion en entiers</title> <simpara> - Pour explicitement convertir une valeur en <type>integer</type>, + Pour explicitement convertir une valeur en &integer;, utilisez les op&eacute;rateurs de transtypage <literal>(int)</literal> ou <literal>(integer)</literal>. Cependant, dans la plupart des situations, vous n'en aurez pas besoin, car une valeur sera @@ -352,14 +384,16 @@ peut conduire &agrave; des r&eacute;sultats irrationnels. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php echo (int) ( (0.1+0.7) * 10 ); // affiche 7! -?&gt; +?> +]]> </programlisting> </informalexample> Pour plus d'informations, reportez-vous aux - <link linkend="language.types.float">alertes</link> li&eacute;es + <link linkend="warn.float-precision">alertes</link> li&eacute;es aux nombres &agrave; virgule flottante. </para> </warning> @@ -408,14 +442,16 @@ sp&eacute;cifi&eacute;s en utilisant la syntaxe suivante: <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $a = 1.234; $a = 1.2e3; -?&gt; +?> +]]> </programlisting> </informalexample> </para> - <warning> + <warning id="warn.float-precision"> <title>Pr&eacute;cision des nombres &agrave; virgule flottante</title> <para> Il est fr&eacute;quent que de simples fractions d&eacute;cimales telles que @@ -442,6 +478,18 @@ librairies <link linkend="ref.bc">BC</link> ou <link linkend="ref.gmp">GMP</link>. </para> </warning> + <sect2 id="language.types.float.casting"> + <title>Conversion d'un nombre &agrave; virgule flottante</title> + + <para> + Pour savoir quand et comment des cha&icirc;nes sont converties en + nombre &agrave; virgule flottante, voyez la section + <link linkend="language.types.string.conversion">Conversion de cha&icirc;nes de caract&egrave;res</link>. + Pour les valeurs d'autres types, la conversion est la m&ecirc;me + que si la valeur &eacute;tait d'abord convertie en entier, puis en + nombre d&eacute;cimal. Voyez la section <link linkend="language.types.integer.casting">Conversion d'un entier</link>. + </para> + </sect2> </sect1> <sect1 id="language.types.string"> <title>Les cha&icirc;nes de caract&egrave;res</title> @@ -511,7 +559,8 @@ </note> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php echo 'Ceci est une cha&icirc;ne simple'; echo 'Vous pouvez inclure des nouvelles lignes dans une cha&icirc;ne, comme ceci.'; @@ -523,7 +572,8 @@ // affiche : Etes vous s&ucirc;r de vouloir effacer le dossier C:\*.*? echo 'Je suis en train de mettre une nouvelle ligne comme ceci : \n'; // affiche : Je suis en train de mettre une nouvelle ligne comme ceci : \n -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -649,8 +699,9 @@ <example> <title>Exemple de cha&icirc;ne HereDoc</title> <programlisting role="php"> -&lt;?php - $str = &lt;&lt;&lt;EOD +<![CDATA[ +<?php + $str = <<<EOD Exemple de cha&icirc;ne s'&eacute;talant sur plusieurs lignes @@ -661,18 +712,19 @@ var $foo; var $bar; function foo() { - $this-&gt;foo = 'Foo'; - $this-&gt;bar = array('Bar1', 'Bar2', 'Bar3'); + $this->foo = 'Foo'; + $this->bar = array('Bar1', 'Bar2', 'Bar3'); } } $foo = new foo(); $name = 'MonNom'; - echo &lt;&lt;&lt;EOT + echo <<<EOT Mon nom est "$name". J'affiche des $foo->foo. - Maintenant, j'affiche un {$foo-&gt;bar[1]}. + Maintenant, j'affiche un {$foo->bar[1]}. Ceci se traduit par un 'A' majuscule: \x41 EOT; -?&gt; +?> +]]> </programlisting> </example> </para> @@ -712,19 +764,22 @@ variable valide. Entourez le nom de la variable avec des accolades pour indiquer explicitement son nom. </simpara> - <informalexample> + <example> + <title>Utilisation des accolades {} dans les cha&icirc;nes</title> <programlisting role="php"> -&lt;?php + <![CDATA[ +<?php $boisson = 'vin'; echo "Du $boisson, du pain et du fromage!'; // OK, car "," n'est pas autoris&eacute; dans les noms de variables - echo "Il a go&ucirc;t&eacute; plusieurs $vins"; + echo "Il a go&ucirc;t&eacute; plusieurs $boisson"; // Pas OK, car 's' peut entrer dans un nom de variable, et PHP recherche $boissons - echo "Il a go&ucirc;t&eacute; plusieurs ${vin}s"; + echo "Il a go&ucirc;t&eacute; plusieurs ${boisson}s"; // OK -?&gt; +?> +]]> </programlisting> - </informalexample> + </example> <simpara> Similairement, vous pouvez aussi utiliser un &eacute;l&eacute;ment de tableau, ou un membre d'objet. Pour les &eacute;l&eacute;ments @@ -740,25 +795,24 @@ paying them enough or something?). --> </simpara> - <informalexample> + <example> + <title>Utilisation des accolades {} dans les cha&icirc;nes pour les tableaux</title> <programlisting role="php"> + <![CDATA[ +<?php $fruits = array( 'fraise' => 'rouge' , 'banane' => 'jaune' ); echo "Une banane est $fruits[banane]."; // OK. Notez toutefois que pour cet exemple, cela fonctionne - // diff&eacute;remment. Voyez <link linkend="language.types.array.foo-bar"><literal>$foo[bar]</literal> hors des cha&icirc;nes</link> - echo "Ce carr&eacute; est large de $carre-&gt;largeur m&egrave;tres."; + // diff&eacute;remment. Voyez <literal>$foo[bar]</literal> hors des cha&icirc;nes + echo "Ce carr&eacute; est large de $carre->largeur m&egrave;tres."; // OK - echo "Ce carr&eacute; est large de $carre-&gt;largeur00 m&egrave;tres.."; + echo "Ce carr&eacute; est large de $carre->largeur00 m&egrave;tres.."; // pas OK - // pour r&eacute;soudre ce probl&egrave;me, voyez <link linkend="language.types.string.parsing.complex">syntaxe complexe</link>. - <!-- XXX this won't work: - echo "This square is $square->{width}00 centimeters broad."; - // XXX: php developers: it would be consequent to make this work. - // XXX: like the $obj->{expr} syntax outside a string works, - // XXX: analogously to the ${expr} syntax for variable var's. - --> + // pour r&eacute;soudre ce probl&egrave;me, voyez la syntaxe complexe. +?> +]]> </programlisting> - </informalexample> + </example> <simpara> Pour tout ce qui sera plus compliqu&eacute;, voyez la syntaxe complexe. </simpara> @@ -783,7 +837,8 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $super = 'fantastique'; echo "C'est { $super}"; // ne fonctionne pas, @@ -791,13 +846,13 @@ echo "C'est {$super}"; // fonctionne, // affiche "C'est fantastique" - echo "Ce carr&eacute; a {$square-&gt;width}00 centim&egrave;tres de large."; + echo "Ce carr&eacute; a {$square->width}00 centim&egrave;tres de large."; echo "Ceci fonctionne : {$tableau[4][3]}"; echo "Ceci &eacute;choue : {$tableau[foo][3]}"; // pour la m&ecirc;me raison que $tableau[bar] ne fonctionne pas hors d'une cha&icirc;ne <!-- XXX see the still-to-write explaination in the arrays-section. --> echo "Essayez plut&ocirc;t comme ceci : {$tableau['foo'][3]}"; - echo "Vous pouvez m&ecirc;me &eacute;crire {$objet-&gt;valeurs[3]-&gt;nom}"; + echo "Vous pouvez m&ecirc;me &eacute;crire {$objet->valeurs[3]->nom}"; echo "Voici la valeur de la variable nomm&eacute;e $name: {${$name}}"; <!-- <xxx> maybe it's better to leave this out?? --> // cela fonctionne, mais c'est vivement d&eacute;conseill&eacute;. @@ -805,7 +860,8 @@ $inv = 'Bordeaux'; echo "Je reprendrai bien un verre de cet excellent {${ strrev('niv') }}, hips"; <!-- </xxx> --> -?&gt; +?> +]]> </programlisting> </informalexample> </sect4> @@ -831,26 +887,28 @@ <!-- TODO: either move these examples to a example section, as with arrays, or distribute them under the applicable sections. --> -&lt;?php +<![CDATA[ +<?php /* Affectation d'une cha&icirc;ne. */ $str = "Ceci est une cha&icirc;ne"; /* Concat&eacute;nation. */ $str = $str . " avec un peu plus de texte"; /* Une autre m&eacute;thode de concat&eacute;nation. */ $str .= " et une nouvelle ligne &agrave; la fin.\n"; -/* Cette cha&icirc;ne finira comme : '&lt;p&gt;Nombre: 9&lt;/p&gt;' */ +/* Cette cha&icirc;ne finira comme : '<p>Nombre: 9</p>' */ $num = 9; - $str = "&lt;p&gt;Nombre: $num&lt;/p&gt;"; -/* Celle-ci sera '&lt;p&gt;Nombre: $num&lt;/p&gt;' */ + $str = "<p>Nombre: $num</p>"; +/* Celle-ci sera '<p>Nombre: $num</p>' */ $num = 9; - $str = '&lt;p&gt;Nombre: $num&lt;/p&gt;'; + $str = '<p>Nombre: $num</p>'; /* Premier caract&egrave;re d'une cha&icirc;ne */ $str = 'Ceci est un test.'; $first = $str{0}; /* Dernier caract&egrave;re d'une cha&icirc;ne. */ $str = 'This is still a test.'; $last = $str{strlen($str)-1}; -?&gt; +?> +]]> </programlisting> </example> </para> @@ -884,8 +942,71 @@ fonctions de <link linkend="ref.ctype">types de caract&egrave;res</link>. </simpara> </sect2> + <sect2 id="language.types.string.casting"> + <title>Conversion de cha&icirc;ne de caract&egrave;res</title> + + <para> + Vous pouvez convertir une valeur en cha&icirc;ne en utilisant l'op&eacute;rateur + <literal>(string)</literal>, ou bien la fonction <function>strval</function>. + La conversion en cha&icirc;ne de caract&egrave;res est automatiquement faite dans + toutes les situations qui n&eacute;cessitent une cha&icirc;ne de caract&egrave;res. + Cela arrive lorsque vous utilisez des fonctions comme <function>echo</function> + ou <function>print</function>, ou encore lorsque vous comparez une valeur + avec une cha&icirc;ne de caract&egrave;res. + </para> + + <para> + Le bool&eacute;en &true; est converti en la cha&icirc;ne de caract&egrave;res <literal>"1"</literal>, + et le bool&eacute;en &false; est repr&eacute;sent&eacute; par la cha&icirc;ne de caract&egrave;res vide + <literal>""</literal>. De cette fa&ccedil;on, vous pouvez convertir des + bool&eacute;ens en cha&icirc;ne de caract&egrave;res et vice-versa. + </para> + <para> + Un entier ou un nombre &agrave; virgule flottante est converti en une + cha&icirc;ne de caract&egrave;res qui repr&eacute;sente ce nombre en d&eacute;cimal (y compris + l'exposant des nombres &agrave; virgule flottante). + </para> + <para> + Les tableaux sont toujours convertis en la cha&icirc;ne de caract&egrave;res <literal>"Array"</literal>, + ce qui fait que vous ne pouvez pas afficher le contenu d'un tableau avec la fonction + <function>echo</function> ou <function>print</function>. Voyez + les informations ci-dessous pour plus de conseils. + </para> + <para> + Les objets sont automatiquement convertis en la cha&icirc;ne de caract&egrave;res + <literal>"Object"</literal>. Si vous souhaitez afficher le membre + d'un objet, lisez le paragraphe ci-dessous. Si vous voulez connaitre + le nom de la classe de cet objet, utilisez la fonction + <function>get_class</function>. + </para> + <para> + Les ressources sont toujours converties en cha&icirc;ne de caract&egrave;res + <literal>"Resource id #1"</literal> o&ugrave; <literal>1</literal> est + le nombre unique repr&eacute;sentant la ressource, assign&eacute; par &php; au moment + de l'ex&eacute;cution. Si vous souhaitez conna&icirc;tre le type d'une ressource, + utilisez <function>get_resource_type</function>. + </para> + <para> + &null; est toujours converti en une cha&icirc;ne de caract&egrave;res vide. + </para> + + <para> + Comme vous pouvez le voir, afficher des tableaux, des objets ou des ressources + n'est pas pertinent par cette m&eacute;thode. Reportez-vous aux fonctions + <function>print_r</function> et <function>var_dump</function> pour + avoir des outils plus pratiques. + </para> + + <para> + Vous pouvez aussi convertir des valeurs &php; en cha&icirc;nes pour les + sauver dans un stockage. Cette m&eacute;thode est appel&eacute;e la lin&eacute;arisation, + et peut &ecirc;tre exploit&eacute;e avec la fonction <function>serialize</function>. + Vous pouvez aussi lin&eacute;ariser des valeurs &php; en structure + XML si vous avez le support <link linkend="ref.wddx">WDDX</link>. + </para> + </sect2> <sect2 id="language.types.string.conversion"> - <title>Conversion de type</title> + <title>Conversion de cha&icirc;nes de caract&egrave;res</title> <simpara> Lorsqu'une cha&icirc;ne de caract&egrave;re est &eacute;valu&eacute;e comme une valeur num&eacute;rique, @@ -911,16 +1032,18 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $foo = 1 + "10.5"; // $foo est du type float (11.5) $foo = 1 + "-1.3e3"; // $foo est du type float (-1299) $foo = 1 + "bob-1.3e3"; // $foo est du type integer (1) $foo = 1 + "bob3"; // $foo est du type integer (1) - $foo = 1 + "10 Small Pigs"; // $foo est du type integer (11) - $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 float (11) -?&gt; + $foo = 1 + "10 petits cochons"; // $foo est du type integer (11) + $foo = 1 + "10 gros cochons"; // $foo est du type integer (11) + $foo = "10.0 cochons " + 1; // $foo est du type integer (11) + $foo = "10.0 cochons " + 1.0; // $foo est du type float (11) +?> +]]> </programlisting> </informalexample> <simpara> @@ -933,9 +1056,11 @@ pour voir comment il se comporte. <informalexample> <programlisting role="php"> -&lt;?php - echo "\$foo==$foo; type is " . gettype( $foo ) . "&lt;br&gt;\n"; -?&gt; +<![CDATA[ +<?php + echo "\$foo==$foo; type is " . gettype( $foo ) . "<br>\n"; +?> +]]> </programlisting> </informalexample> </para> @@ -966,7 +1091,7 @@ <para> Un tableau <type>array</type> peut &ecirc;tre cr&eacute;&eacute; avec la fonction <function>array</function>. Cette fonction prend en argument - des structures <literal><replaceable>key</replaceable> =&gt; + des structures <literal><replaceable>key</replaceable> => <replaceable>value</replaceable></literal>, s&eacute;par&eacute;es par des virgules. </para> <para> @@ -991,9 +1116,17 @@ </para> <para> Une valeur peut &ecirc;tre n'importe quoi. + <example> + <title>Cr&eacute;ation d'un tableau</title> + <programlisting role="php"> +<![CDATA[ +<?php + array("somearray" => array(6 => 5, 13 => 9, "a" => 43)); +?> +]]> + </programlisting> + </example> </para> - <sect4 id="language.types.array.omit-key"> - <title>Omettre des cl&eacute;s</title> <para> Si vous omettez une cl&eacute; lors de la sp&eacute;cification d'un tableau, l'indice maximum + 1 sera utilis&eacute; comme cl&eacute; par d&eacute;faut. Si aucun @@ -1003,7 +1136,7 @@ </para> <para> <synopsis> -array( <optional><replaceable>key</replaceable> =&gt; </optional> +array( <optional><replaceable>key</replaceable> => </optional> <replaceable>value</replaceable> , ... ) @@ -1012,7 +1145,6 @@ // <replaceable>value</replaceable> peut &ecirc;tre n'importe quoi </synopsis> </para> - </sect4> </sect3> <sect3 id="language.types.array.syntax.modifying"> <title>La syntaxe &agrave; crochets</title> @@ -1049,6 +1181,130 @@ revue simplement les valeurs d'un tableau. </para> </sect2> + <sect2 id="language.types.array.donts"> + <title>Attention aux tableaux</title> + <sect3 id="language.types.array.foo-bar"> + <title>Pourquoi est ce que <literal>$foo[bar]</literal> est invalide?</title> + <para> + Dans vos vieux scripts, vous pouvez avoir utilis&eacute; la syntaxe suivante : + <informalexample> + <programlisting role="php"> +<![CDATA[ +<?php + $foo[bar] = 'ennemi'; + echo $foo[bar]; +?> +]]> + </programlisting> + </informalexample> + Cela est mauvais, mais ca marche. Pourquoi est-ce mauvais? La raison + est que PHP r&eacute;clame une expression entre les crochets (comme + indiqu&eacute; dans la section sur la + <link linkend="language.types.array.syntax">syntaxe</link> des tableaux). + Cela signifie que vous pouvez &eacute;crire quelque chose comme : + <informalexample> + <programlisting role="php"> +<![CDATA[ +<?php + echo $arr[ foo(true) ]; +?> +]]> + </programlisting> + </informalexample> + Ceci est un exemple d'utilisation de retour de fonction dans un + index de tableau. PHP reconnait aussi les constantes, et vous + pouvez avoir d&eacute;j&agrave; rencontr&eacute; <literal>E_*</literal>. + <informalexample> + <programlisting role="php"> +<![CDATA[ +<?php + $error_descriptions[E_ERROR] = "Une erreur fatale est survenue"; + $error_descriptions[E_WARNING] = "PHP a g&eacute;n&eacute;r&eacute; une alerte"; + $error_descriptions[E_NOTICE] = "Ceci est juste une note gr&acirc;cieuse"; +?> +]]> + </programlisting> + </informalexample> + Notez que <literal>E_ERROR</literal> est aussi un identifiant + vlaide, tout comme <literal>bar</literal> dans le premier exemple. + Mais le dernier exemple revient &agrave; &eacute;crire : + <informalexample> + <programlisting role="php"> +<![CDATA[ +<?php + $error_descriptions[1] = "Une erreur fatale est survenue"; + $error_descriptions[2] = "PHP a g&eacute;n&eacute;r&eacute; une alerte"; + $error_descriptions[8] = "Ceci est juste une note gr&acirc;cieuse"; +?> +]]> + </programlisting> + </informalexample> + car <literal>E_ERROR</literal> &eacute;gale <literal>1</literal>, etc. + </para> + <para> + Alors, comment se fait-t-il que <literal>$foo[bar]</literal> fonctionne? + C'est parce que <literal>bar</literal> est consid&eacute;r&eacute; comme une + constante. Cependant, dans ce cas, aucune constante n'a pour nom + <literal>bar</literal>. PHP suppose alors que vous voulez dire + <literal>bar</literal> litt&eacute;ralement, c'est-&agrave;-dire la + cha&icirc;ne <literal>"bar"</literal>, mais que vous avez oubli&eacute; les + guillements. + </para> + <para> + Dans le futur, l'&eacute;quipe de d&eacute;veloppement peut vouloir ajouter une + nouvelle constante et vous vous retrouverez dans la panade. Par + exemple, vous ne pouvez d&eacute;j&agrave; pas utiliser les constantes + <literal>empty</literal> et <literal>default</literal>, car ce + sont des mots reserv&eacute;s. + <!-- <jeroen>hmm... i'm doubting this myself. Finish it if you like</jeroen> + But probably + the most threatening + thing is yourself, or whoever will maintain the script. You'll + maybe get very strange behaviour, and + --> + </para> + <para> + Et, pour en mettre une autre couche, cette syntaxe est tout simplement + obsol&egrave;te, et risque de ne plus fonctionner du tout un jour ou l'autre. + </para> + <note> + <simpara> + Lorsque vous activez le rapport d'erreur avec <function>error_reporting</function> + avec <literal>E_ALL</literal>, PHP g&eacute;n&eacute;rera des notes &agrave; chaque fois que cette + syntaxe est utilis&eacute;e. Essayez donc <literal>error_reporting(E_ALL);</literal> + dans vos scripts, pour voir). + </simpara> + </note> + <note> + <simpara> + Dans une cha&icirc;ne &agrave; guillements doubles, une autre syntaxe est + valide. Voyez la section sur + <link linkend="language.types.string.parsing">Traitement des variables + dans les cha&icirc;nes</link> pour plus de d&eacute;tails. + </simpara> + </note> + </sect3> + </sect2> + <sect2 id="language.types.array.casting"> + <title>Conversion en tableau</title> + + <para> + Pour les types scalaires (integer, float, string, boolean et resource), + convertir une valeur en tableau retourne un tableau qui contient un + &eacute;l&eacute;ment (&agrave; l'index 0) qui est la valeur originale. + </para> + + <para> + Si vous convertissez un tableau en objet, vous obtiendrez des propri&eacute;t&eacute;s + ou bien cet objet comme &eacute;lements de tableau. Les cl&eacute;s cr&eacute;&eacute;es sont les + noms des membres. + </para> + + <para> + Si vous convertissez la valeur &null; en tableau, vous obtiendrez un + taleau vide. + </para> + </sect2> <sect2 id="language.types.array.examples"> <title>Exemples</title> <para> @@ -1057,7 +1313,8 @@ <para> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php // ceci $a = array( 'couleur' => 'rouge' , 'gout' => 'sucre' @@ -1076,19 +1333,21 @@ $b[] = 'c'; // va cr&eacute;er le tableau array( 0 => 'a' , 1 => 'b' , 2 => 'c' ) // ou plus simplement array('a' , 'b' , 'c' ) -?&lt; +?> +]]> </programlisting> </informalexample> </para> <example> <title>Utilisation de <function>array</function></title> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php // Array comme correspondance - $map = array( 'version' =&gt; 4 - , 'OS' =&gt; 'Linux' - , 'langue' =&gt; 'fran&ccedil;ais' - , 'short_tags' =&gt; TRUE ); + $map = array( 'version' => 4 + , 'OS' => 'Linux' + , 'langue' => 'fran&ccedil;ais' + , 'short_tags' => TRUE ); // valeur strictement num&eacute;riques $array = array( 7 , 8 @@ -1096,15 +1355,15 @@ , 156 , -10 ); -// ceci est la m&ecirc;me chose que array( 0 =&gt; 7, 1 =&gt; 8, ...) +// ceci est la m&ecirc;me chose que array( 0 => 7, 1 => 8, ...) $switching = array( 10 // cl&eacute; = 0 - , 5 =&gt; 6 - , 3 =&gt; 7 - , 'a' =&gt; 4 + , 5 => 6 + , 3 => 7 + , 'a' => 4 , 11 // cl&eacute; = 6 (index maximum : 5) - , '8' =&gt; 2 // cl&eacute; = 8 (entier!) - , '02' =&gt; 77 // cl&eacute; = '02' - , 0 =&gt; 12 // la valeur de la cl&eacute; 10 sera remplac&eacute;e par 12 + , '8' => 2 // cl&eacute; = 8 (entier!) + , '02' => 77 // cl&eacute; = '02' + , 0 => 12 // la valeur de la cl&eacute; 10 sera remplac&eacute;e par 12 ); <!-- TODO example of - mixed keys @@ -1115,13 +1374,15 @@ --> // empty array $empty = array(); -?&lt; +?> +]]> </programlisting> </example> <example id="language.types.array.examples.loop"> <title>Collection</title> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $couleurs = array('rouge','bleu','vert','jaune'); foreach ( $couleurs as $couleur ){ echo "Aimez-vous la couleur $couleur?\n"; @@ -1132,7 +1393,8 @@ Aimez-vous la couleur vert? Aimez-vous la couleur jaune? */ -?&gt; +?> +]]> </programlisting> </example> <para> @@ -1147,7 +1409,8 @@ <example id="language.types.array.examples.changeloop"> <title>Collection</title> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php foreach( $couleurs as $cle => $couleur ){ // ne marche pas //$couleur = strtoupper($couleur); @@ -1164,7 +1427,8 @@ [3] => JAUNE ) */ -?&gt; +?> +]]> </programlisting> </example> </para> @@ -1173,7 +1437,8 @@ <example> <title>Tableau en 1</title> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $firstquarter = array(1 => 'Janvier', 'F&eacute;vrier', 'Mars'); print_r($firstquarter); /* Affiche: @@ -1184,21 +1449,24 @@ [3] => 'Mars' ) */ -?&gt; +?> +]]> </programlisting> </example> </para> <example> <title>Remplissage d'un tableau</title> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php // remplis un tableau avec les noms de fichiers d'un dossier $handle = opendir('.'); while ( $file = readdir($handle) ){ $files[] = $file; } closedir($handle); -?&gt; +?> +]]> </programlisting> </example> <para> @@ -1209,10 +1477,12 @@ <example> <title>Tri de tableaux</title> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php sort($files); print_r($files); -?&gt; +?> +]]> </programlisting> </example> <para> @@ -1223,20 +1493,21 @@ <example> <title>Tableaux multi-dimensionnels, et r&eacute;cursifs</title> <programlisting role="php"> -&lt;?php - $fruits = array ( "fruits" =&gt; array ( "a" =&gt; "orange" - , "b" =&gt; "banane" - , "c" =&gt; "pomme" +<![CDATA[ +<?php + $fruits = array ( "fruits" => array ( "a" => "orange" + , "b" => "banane" + , "c" => "pomme" ) - , "nombres" =&gt; array ( 1 + , "nombres" => array ( 1 , 2 , 3 , 4 , 5 , 6 ) - , "trous" =&gt; array ( "premier" - , 5 =&gt; "second" + , "trous" => array ( "premier" + , 5 => "second" , "troisi&egrave;me" ) ); @@ -1259,294 +1530,11 @@ ) ); --> -?&gt; +?> +]]> </programlisting> </example> </sect2> - <sect2 id="language.types.array.donts"> - <title>Attention aux tableaux</title> - <sect3 id="language.types.array.foo-bar"> - <title>Pourquoi est ce que <literal>$foo[bar]</literal> est invalide?</title> - <para> - Dans vos vieux scripts, vous pouvez avoir utilis&eacute; la syntaxe suivante : - <informalexample> - <programlisting role="php"> -&lt;?php - $foo[bar] = 'ennemi'; - echo $foo[bar]; -?&gt; - </programlisting> - </informalexample> - Cela est mauvais, mais ca marche. Pourquoi est-ce mauvais? La raison - est que PHP r&eacute;clame une expression entre les crochets (comme - indiqu&eacute; dans la section sur la - <link linkend="language.types.array.syntax">syntaxe</link> des tableaux). - Cela signifie que vous pouvez &eacute;crire quelque chose comme : - <informalexample> - <programlisting role="php"> -&lt;?php - echo $arr[ foo(true) ]; -?&gt; - </programlisting> - </informalexample> - Ceci est un exemple d'utilisation de retour de fonction dans un - index de tableau. PHP reconnait aussi les constantes, et vous - pouvez avoir d&eacute;j&agrave; rencontr&eacute; <literal>E_*</literal>. - <informalexample> - <programlisting role="php"> -&lt;?php - $error_descriptions[E_ERROR] = "Une erreur fatale est survenue"; - $error_descriptions[E_WARNING] = "PHP a g&eacute;n&eacute;r&eacute; une alerte"; - $error_descriptions[E_NOTICE] = "Ceci est juste une note gr&acirc;cieuse"; -?&gt; - </programlisting> - </informalexample> - Notez que <literal>E_ERROR</literal> est aussi un identifiant - vlaide, tout comme <literal>bar</literal> dans le premier exemple. - Mais le dernier exemple revient &agrave; &eacute;crire : - <informalexample> - <programlisting role="php"> -&lt;?php - $error_descriptions[1] = "Une erreur fatale est survenue"; - $error_descriptions[2] = "PHP a g&eacute;n&eacute;r&eacute; une alerte"; - $error_descriptions[8] = "Ceci est juste une note gr&acirc;cieuse"; -?&gt; - </programlisting> - </informalexample> - car <literal>E_ERROR</literal> &eacute;gale <literal>1</literal>, etc. - </para> - <para> - Alors, comment se fait-tile que <literal>$foo[bar]</literal> fonctionne? - C'est parce que <literal>bar</literal> est attendu comme une - constante. Cependant, dans ce cas, aucune constante n'a pour nom - <literal>bar</literal>. PHP suppose alors que vous voulez dire - <literal>bar</literal> litt&eacute;ralement, c'est-&agrave;-dire la - cha&icirc;ne <literal>"bar"</literal>, mais que vous avez oubli&eacute; les - guillements. - </para> - <sect4 id="language.types.array.foo-bar.why"> - <title>Alors, pourquoi est-ce mal?</title> - <para> - Dans le futur, l'&eacute;quipe de d&eacute;veloppement peut vouloir ajouter une - nouvelle constante et vous vous retrouverez dans la panade. Par - exemple, vous ne pouvez d&eacute;j&agrave; pas utiliser les constantes - <literal>empty</literal> et <literal>default</literal>, car ce - sont des mots reserv&eacute;s. - <!-- <jeroen>hmm... i'm doubting this myself. Finish it if you like</jeroen> - But probably - the most threatening - thing is yourself, or whoever will maintain the script. You'll - maybe get very strange behaviour, and - --> - </para> - <para> - Et, pour en mettre une autre couche, cette syntaxe est tout simplement - obsol&egrave;te, et risque de ne plus fonctionner du tout un jour ou l'autre. - </para> - <note> - <simpara> - Lorsque vous activez le rapport d'erreur avec <function>error_reporting</function> - avec <literal>E_ALL</literal>, PHP g&eacute;n&eacute;rera des notes &agrave; chaque fois que cette - syntaxe est utilis&eacute;e. Essayez donc <literal>error_reporting(E_ALL);</literal> - dans vos scripts, pour voir). - </simpara> - </note> - <note> - <simpara> - Dans une cha&icirc;ne &agrave; guillements doubles, une autre syntaxe est - valide. Voyez la section sur - <link linkend="language.types.string.parsing">Traitement des variables - dans les cha&icirc;nes</link> pour plus de d&eacute;tails. - </simpara> - </note> - </sect4> - </sect3> - </sect2> - <!-- TODO - - example multi-dim with $arr[bla][bla] syntax - - converting to array - - warning about references - - note that assigning is copy (usually...) - --> -<!-- there is no such thing as multi/singel dim arrays (at least in PHP4) - <sect2 id="language.types.array.single-dim"> - <title>Single Dimension Arrays</title> - <para> - PHP supports both scalar and associative arrays. In fact, there - is no difference between the two. You can create an array using -- the <function>list</function> or <function>array</function> - the - <function>list</function> - Nope - or <function>array</function> - functions, or you can explicitly set each array element value. - ++++++++++++++++++++++++++++++++++++++++++++ - <para> - Les tableaux ressemblent aux tableaux associatifs et - aux tableaux index&eacute;s (vecteurs).</para> - <sect2 id="language.types.array.single-dim"> - <title>Tableaux &agrave; une dimension</title> - <para> - PHP supporte les tableaux scalaires et les tableaux associatifs. - En fait, il n'y a aucune diff&eacute;rence entre les deux. Vous - pouvez cr&eacute;er un tableau en utilisant les fonctions - <function>list</function> ou <function>array</function>, ou bien - en affectant explicitement chacune des valeurs. - <informalexample> - <programlisting role="php"> -&lt;?php -$a[0] = "abc"; -$a[1] = "def"; -$b["foo"] = 13; -?&gt; - </programlisting> - </informalexample> - </para> - <para> - Vous pouvez aussi cr&eacute;er un tableau en ajoutant - simplement les valeurs &agrave; ce tableau. - <informalexample> - <programlisting role="php"> -&lt;?php -$a[] = "Bonjour"; // $a[2] == "Bonjour"; -$a[] = "Monde"; // $a[3] == "Monde"; -?&gt; - </programlisting> - </informalexample> - </para> - <para> - Un tableau peut &ecirc;tre tri&eacute; en utilisant les fonctions - <function>asort</function>, - <function>arsort</function>, <function>ksort</function>, - <function>rsort</function>, <function>sort</function>, - <function>uasort</function>, <function>usort</function>, ou - <function>uksort</function> en fonction du type de classement que vous voulez. - </para> - <para> - Vous pouvez compter le nombre d'&eacute;l&eacute;ments qu'il y - a dans un tableau en utilisant la fonction <function>count</function>. - </para> - <para> - Vous pouvez-vous d&eacute;placer &agrave; l'int&eacute;rieur d'un - tableau en utilisant les fonctions <function>next</function> et - <function>prev</function>. Un autre moyen de se d&eacute;placer - dans un tableau est d'utiliser la fonction <function>each</function>. - </para> - </sect2> - <sect2 id="language.types.array.multi-dim"> - <title>Tableaux &agrave; plusieurs dimensions</title> - <para> - Les tableaux &agrave; plusieurs dimensions sont extr&ecirc;mement simples. - Pour chaque dimension du tableau, vous ajouter une nouvelle [clef] &agrave; - la fin: - <informalexample> - <programlisting role="php"> -&lt;?php -$a[1] = $f; # tableau &agrave; une dimension -$a["foo"] = $f; -$a[1][0] = $f; # tableau &agrave; deux dimensions -$a["foo"][2] = $f; # vous pouvez m&eacute;langer les indices associatifs et num&eacute;riques -$a[3]["bar"] = $f; # vous pouvez m&eacute;langer les indices associatifs et num&eacute;riques -$a["foo"][4]["bar"][0] = $f; # tableau &agrave; quatre dimensions -?&gt; - </programlisting> - </informalexample> - </para> - <para> - En PHP 3 il n'est pas possible de r&eacute;f&eacute;rencer un tableau - &agrave; l'int&eacute;rieur d'une cha&icirc;ne. Par exemple, ceci ne - fonctionne pas : - <informalexample> - <programlisting role="php"> -&lt;?php -$a[3]['bar'] = 'Bob'; -echo "Cela ne marche pas : $a[3][bar]"; -?&gt; - </programlisting> - </informalexample> - En PHP 3, l'exemple ci-dessus va afficher : - <computeroutput>Cela ne marche pas : Array[bar]</computeroutput>. - L'op&eacute;rateur de concat&eacute;nation, - peut &ecirc;tre utilis&eacute; pour corriger cela : - <informalexample> - <programlisting role="php"> -&lt;?php -$a[3]['bar'] = 'Bob'; -echo "Cela ne marche pas : " . $a[3][bar]; -?&gt; - </programlisting> - </informalexample> - </para> - <para> - En PHP 4, cependant, le probl&egrave;me peut &ecirc;tre contourn&eacute; - en entourant le tableau par des accolades : - <informalexample> - <programlisting role="php"> -&lt;?php -$a[3]['bar'] = 'Bob'; -echo "Cela marche : {$a[3][bar]}"; -?&gt; - </programlisting> - </informalexample> - </para> - <para> - Vous pouvez remplir un tableau &agrave; plusieurs dimensions - par de nombreux moyens mais la m&eacute;thode la plus simple - &agrave; comprendre est l'utilisation de la fonction - <function>array</function>. Les deux exemples suivants - montre comment remplir un tableau &agrave; une dimension: - <informalexample> - <programlisting role="php"> -&lt;?php -# Exemple 1: -$a["couleur"] = "rouge"; -$a["saveur"] = "sucr&eacute;e"; -$a["forme"] = "rond"; -$a["nom"] = "pomme"; -$a[3] = 4; -# Exemple 2: -$a = array( - "couleur" =&gt; "rouge", - "saveur" =&gt; "sucr&eacute;e", - "forme" =&gt; "rond", - "nom" =&gt; "pomme", - 3 =&gt; 4 -); -?&gt; - </programlisting> - </informalexample> - </para> - <para> - La fonction <function>array</function> peut &ecirc;tre - embo&icirc;t&eacute;e pour remplir un tableau &agrave; - plusieurs dimensions : - <informalexample> - <programlisting role="php"> -&lt;?php -$a = array( - "pomme" =&gt; array( - "couleur" =&gt; "rouge", - "saveur" =&gt; "sucr&eacute;e", - "forme" =&gt; "rond" - ), - "orange" =&gt; array( - "couleur" =&gt; "orange", - "saveur" =&gt; "am&egrave;re", - "forme" =&gt; "rond" - ), - "banane" =&gt; array( - "couleur" =&gt; "jaune", - "saveur" =&gt; "paste-y", - "forme" =&gt; "banano&iuml;de" - ) -); -echo $a["pomme"]["saveur"]; # va afficher "sucr&eacute;e" -?&gt; - </programlisting> - </informalexample> - </para>+ - </sect2> - --> </sect1> <sect1 id="language.types.object"> <title>Les objets</title> @@ -1557,15 +1545,38 @@ afin de cr&eacute;er linstance de l'objet. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php class foo { function faire_foo () { echo "Faisant foo."; } } $bar = new foo; - $bar-&gt;faire_foo(); -?&gt; + $bar->faire_foo(); +?> +]]> + </programlisting> + </informalexample> + </para> + </sect2> + <sect2 id="language.types.object.casting"> + <title>Converting to object</title> + + <para> + Si un objet est converti en objet, il n'est pas modifi&eacute;. Si une + valeur d'un autre type est convertie en objet, une nouvelle instance + de la classe <literal>stdClass</literal> sera cr&eacute;&eacute;e. Si la valeur + &eacute;tait &null; la nouvelle instance sera vide. Pour les autres valeurs, + un membre de l'objet appel&eacute; <literal>scalar</literal> contiendra la valeur. + <informalexample> + <programlisting role="php"> +<![CDATA[ +<?php + $obj = (object) 'au revoir'; + echo $obj->scalar; // affiche 'au revoir' +?> +]]> </programlisting> </informalexample> </para> @@ -1574,18 +1585,28 @@ <sect1 id="language.types.resource"> <title>Ressources</title> <para> - Une ressource (resource en anglais), est un type sp&eacute;cial, + Une ressource ("resource" en anglais), est un type sp&eacute;cial, qui repr&eacute;sente une r&eacute;f&eacute;rence sur une ressource externe. Les ressources sont cr&eacute;&eacute;es par des fonctions d&eacute;di&eacute;es. Reportez - vous &agrave; l'annexe <link linkend="resources">ressource</link> + vous &agrave; l'annexe <link linkend="resource">Types des ressources PHP</link> pour une liste exhaustive des fonctions cr&eacute;ant et utilisant ces ressources. </para> <note> <simpara> - Le type ressource a &eacute;t&eacute; introduit en PHP 4. + Le type de donn&eacute;es "resource" a &eacute;t&eacute; introduit en PHP 4. </simpara> </note> + <sect2 id="language.types.resource.casting"> + <title>Conversion en ressource</title> + + <para> + Comme les ressources contiennent des valeurs tr&egrave;s sp&eacute;ciales, + comme des fichiers ouverts, des connexions aux bases de donn&eacute;es, + des images ou n'importe quoi d'autre, vous ne pouvez pas + convertir une valeur en ressource. + </para> + </sect2> <sect2 id="language.types.resource.self-destruct"> <title>Lib&eacute;rer des ressources</title> <para> @@ -1619,9 +1640,11 @@ <literal>NULL</literal>, insensible &agrave; la casse. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $var = Null; -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -1632,6 +1655,101 @@ </note> </sect2> </sect1> + <sect1 id="language.pseudo-types"> + <title>Pseudo-types used in this documentation</title> + + <sect2 id="language.types.mixed"> + <title>mixed</title> + <para> + <literal>mixed</literal> indique qu'un param&egrave;tre accepte + plusieurs types, mais pas forc&eacute;ment tous les types. + </para> + <para> + <function>gettype</function> par exemple, accepte tous les types de variables + &php;, mais <function>str_replace</function> n'accepte que des + &string; et des &array;. + </para> + </sect2> + + <sect2 id="language.types.number"> + <title>number</title> + <para> + <literal>number</literal> indique qu'un param&egrave;tre peut &ecirc;tre du type + &integer; ou &float;. + </para> + </sect2> + + <sect2 id="language.types.callback"> + <title>callback</title> + <para> + Certaines fonctions comme par exemple <function>call_user_function</function> + ou <function>usort</function> accepte une fonction d&eacute;finie par + l'utilisateur comme fonction de callback. Les fonctions de + callback peuvent &ecirc;tre des fonctions simples, mais aussi des + objets ou des m&eacute;thodes statiques de classe. + </para> + <para> + Une fonction &php; est pass&eacute;e simplement en indiquant son nom, sous + forme de cha&icirc;ne de caract&egrave;res. Vous pouvez passer une fonction + int&eacute;gr&eacute;e au langage, ou une fonction d&eacute;finie par vos soins, &agrave; + l'exception de + <function>array</function>, + <function>echo</function>, + <function>empty</function>, + <function>eval</function>, + <function>exit</function>, + <function>isset</function>, + <function>list</function>, + <function>print</function> et + <function>unset</function>. + </para> + <para> + Une m&eacute;thode d'un objet instanci&eacute; est pass&eacute;e sous forme de &array;, + contenat un objet comme &eacute;l&eacute;ment d'index 0, et un nom de m&eacute;thode comme + &eacute;l&eacute;ment 1. + </para> + <para> + Les m&eacute;thodes statiques de classe peuvent aussi &ecirc;tre pass&eacute;es dans l'objet + instanci&eacute;, mais en passant le nom de la classe comme valeur de + l'index 0. + </para> + + <para> + <example> + <title> + Exemple de fonction de callback + </title> + <programlisting role="php"> +<![CDATA[ +<?php + +// simple callback example +function foobar() { + echo "hello world!"; +} +call_user_function("foobar"); + +// method callback examples +class foo { + function bar() { + echo "hello world!"; + } +} + +$foo = new foo; + +call_user_function(array($foo, "bar")); // object method call + +call_user_function(array("foo", "bar")); // static class method call + +?> +]]> + </programlisting> + </example> + </para> + </sect2> + </sect1> + <sect1 id="language.types.type-juggling"> <title>D&eacute;finition du type</title> <simpara> @@ -1655,13 +1773,15 @@ sont &eacute;valu&eacute;es. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $foo = "0"; // $foo est une cha&icirc;ne de caract&egrave;res (ASCII 48) $foo += 2; // $foo est maintenant du type entier (2) $foo = $foo + 1.3; // $foo est maintenant du type double (3.3) $foo = 5 + "10 Petits cochons"; // $foo est du type entier (15) $foo = 5 + "10 cochonnets"; // $foo est du type entier (15) -?&gt; +?> +]]> <!-- TODO: explain ++/- - behaviour with strings examples: @@ -1699,9 +1819,11 @@ un copier/coller, et d'ins&eacute;rer les lignes dans un script PHP. <informalexample> <programlisting role="php"> -&lt;?php - echo "\$foo==$foo; le type est " . gettype( $foo ) . "&lt;br&gt;\n"; -?&gt; +<![CDATA[ +<?php + echo "\$foo==$foo; le type est " . gettype( $foo ) . "<br>\n"; +?> +]]> </programlisting> </informalexample> </para> @@ -1711,10 +1833,12 @@ ind&eacute;finie. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $a = 1; // $a est un entier $a[0] = "f"; // $a devient un tableau, et $a[0] contient "f" -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -1724,10 +1848,12 @@ est 'f', consid&eacute;rez l'exemple suivant : <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $a = "1"; // $a est une cha&icirc;ne $a[0] = "f"; // Qu'est ce qu'une position dans une cha&icirc;ne ? que se passe t il? -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -1755,10 +1881,12 @@ &agrave; transtyper ("cast"). <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $foo = 10; // $foo est un entier $bar = (double) $foo; // $bar est un double -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -1791,10 +1919,12 @@ parenth&egrave;ses, donc les lignes suivantes sont &eacute;quivalentes: <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $foo = (int) $bar; $foo = ( int ) $bar; -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -1867,11 +1997,13 @@ &eacute;l&eacute;ment du tableau. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $var = 'ciao'; $arr = (array) $var; echo $arr[0]; // affiche 'ciao' -?&gt; +?> +]]> </programlisting> </informalexample> </para> @@ -1881,11 +2013,13 @@ l'objet. L'attribut s'appellera 'scalar': <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $var = 'ciao'; $obj = (object) $var; - echo $obj-&gt;scalar; // affiche 'ciao' -?&gt; + echo $obj->scalar; // affiche 'ciao' +?> +]]> </programlisting> </informalexample> </para> Index: phpdoc-fr/language/variables.xml diff -u phpdoc-fr/language/variables.xml:1.33 phpdoc-fr/language/variables.xml:1.34 --- phpdoc-fr/language/variables.xml:1.33 Thu May 9 12:06:24 2002 +++ phpdoc-fr/language/variables.xml Mon Feb 3 07:27:12 2003 @@ -1,17 +1,17 @@ <?xml version="1.0" encoding="iso-8859-1"?> -<!-- $Revision: 1.33 $ --> +<!-- $Revision: 1.34 $ --> <chapter id="language.variables"> <title>Les variables</title> <sect1 id="language.variables.basics"> <title>Essentiel</title> <simpara> - En PHP, les variables sont repr&eacute;sent&eacute;es par un signe + En &php;, les variables sont repr&eacute;sent&eacute;es par un signe dollar "$" suivi du nom de la variable. Le nom est sensible &agrave; la casse (ie : $x != $X). </simpara> <para> Les noms de variables suivent les m&ecirc;mes r&egrave;gles de nommage que - les autres entit&eacute;s PHP. Un nom de variable valide doit commencer par + les autres entit&eacute;s &php;. Un nom de variable valide doit commencer par une lettre ou un soulign&eacute; (_), suivi de lettres, chiffres ou soulign&eacute;s. Exprim&eacute; sous la forme d'une expression r&eacute;guli&egrave;re, cela donne : @@ -25,21 +25,23 @@ </simpara> </note> <para> - <informalexample> + <example> <programlisting role="php"> -&lt;?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&eacute; -$ma&#239;s = 'jaune'; // valide; '&iuml;' est ASCII 239. -?&gt; +<![CDATA[ +<?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&eacute; + $ma&#239;s = 'jaune'; // valide; '&iuml;' est ASCII 239. +?> +]]> </programlisting> - </informalexample> + </example> </para> <para> - En PHP 3, les variables sont toujours assign&eacute;es par valeur. + En &php; 3, les variables sont toujours assign&eacute;es par valeur. C'est-&agrave;-dire, lorsque vous assignez une expression &agrave; une variable, la valeur de l'expression est recopi&eacute;e dans la variable. Cela signifie, par exemple, qu'apr&egrave;s avoir @@ -49,7 +51,7 @@ <link linkend="language.expressions">Expressions</link>. </para> <para> - PHP 4 permet aussi d'assigner les valeurs aux variables + &php; 4 permet aussi d'assigner les valeurs aux variables <emphasis>par r&eacute;f&eacute;rence</emphasis>. Cela signifie que la nouvelle variable ne fait que r&eacute;f&eacute;rencer (en d'autres terme, "devient un alias de", ou encore "pointe sur") la @@ -63,17 +65,20 @@ Pour assigner par r&eacute;f&eacute;rence, ajoutez simplement un &amp; (ET commercial) au d&eacute;but de la variable qui est assign&eacute;e (la variable source). Dans l'exemple suivant, - &quot;<literal>Mon nom est Pierre</literal>&quot; s'affichera deux + <literal>Mon nom est Pierre</literal> s'affichera deux fois : <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $foo = 'Pierre'; // Assigne la valeur 'Pierre' &agrave; $foo -$bar = &amp;$foo; // R&eacute;f&eacute;rence $foo avec $bar. +$bar = &$foo; // R&eacute;f&eacute;rence $foo avec $bar. $bar = "Mon nom est Pierre"; // Modifie $bar... echo $foo; // $foo est aussi modifi&eacute;e echo $bar; -?&gt; +?> +]]> + </programlisting> </informalexample> </para> @@ -82,15 +87,18 @@ nomm&eacute;es peuvent &ecirc;tre assign&eacute;es par r&eacute;f&eacute;rence. <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $foo = 25; -$bar = &amp;$foo; // assignation valide . -$bar = &amp;(24 * 7); // assignation invalide : r&eacute;f&eacute;rence une expression sans nom +$bar = &$foo; // assignation valide . +$bar = &(24 * 7); // assignation invalide : r&eacute;f&eacute;rence une expression sans nom function test() { return 25; } -$bar = &amp;test(); // assignation invalide. -?&gt; +$bar = &test(); // assignation invalide. +?> +]]> + </programlisting> </informalexample> </para> @@ -98,49 +106,51 @@ <sect1 id="language.variables.predefined"> <title>Variables pr&eacute;d&eacute;finies</title> <simpara> - PHP fourni un grand nombre de variables pr&eacute;d&eacute;finies. + &php; fourni un grand nombre de variables pr&eacute;d&eacute;finies. Cependant, beaucoup de ces variables ne peuvent pas &ecirc;tre pr&eacute;sent&eacute;es ici, car elles d&eacute;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 + de ces variables ne seront pas accessibles lorsque &php; fonctionne en ex&eacute;cutable. </simpara> <warning> <simpara> - En PHP 4.2.0 et plus r&eacute;cent, le jeu de variables pr&eacute;d&eacute;finies qui sont + En &php; 4.2.0 et plus r&eacute;cent, le jeu de variables pr&eacute;d&eacute;finies qui sont disponibles dans l'environnement global a chang&eacute;. Les variables d'entr&eacute;es et de serveurs ne sont plus <emphasis>par d&eacute;faut</emphasis> plac&eacute;es dans le contexte d'ex&eacute;cution global. Elles sont plac&eacute;es dans les <link linkend="language.variables.superglobals">tableaux superglobaux</link>. </simpara> <simpara> - Vous pouvez toujours forcer l'ancien comportement de PHP en le configurant + Vous pouvez toujours forcer l'ancien comportement de &php; en le configurant avec <link linkend="ini.register-globals">register_globals</link> &agrave; <literal>On</literal> votre fichier &php.ini;. </simpara> <simpara> Pour plus d'informations et d'explications sur ce changement, voyez - <ulink url="&url.php.release4.1.0;">l'annonce de PHP 4.1.0</ulink> (en anglais). + <ulink url="&url.php.release4.1.0;">l'annonce de &php; 4.1.0</ulink> + et and <ulink url="&url.php.release4.2.0;">l'annonce de &php; 4.2.0</ulink> + (en anglais). </simpara> </warning> <simpara> - Depuis la version 4.1.0, PHP fourni un jeu de tableaux + Depuis la version 4.1.0, &php; fournit un jeu de tableaux pr&eacute;d&eacute;finis, contenant les variables du serveur (si possible), les variables d'environnement et celle d'entr&eacute;es. Ces nouveaux tableaux sont un peut particuliers, car ils ont automatiquement globaux : ils sont automatiquement disponibles dans tous les environnements d'ex&eacute;cution, sans avoir &agrave; utiliser le mot r&eacute;serv&eacute; <literal>global</literal>. Pour cette raison, ils sont dits 'auto-globaux' ou bien encore - 'superglobaux' (il n'y a pas de m&eacute;canisme PHP pour cr&eacute;er de telles + 'superglobaux' (il n'y a pas de m&eacute;canisme &php; pour cr&eacute;er de telles variables. Les superglobales sont list&eacute;es ci-dessous. Cependant, pour conna&icirc;tre le d&eacute;tails de leur contenu, et une pr&eacute;sentation approfondie - sur les variables pr&eacute;d&eacute;finies PHP, et leur nature, reportez vous + sur les variables pr&eacute;d&eacute;finies &php;, et leur nature, reportez vous &agrave; la section <link linkend="reserved.variables">variables pr&eacute;definies</link>. </simpara> <variablelist id="language.variables.superglobals"> - <title>Tableaux superglobaux de PHP</title> + <title>Tableaux superglobaux de &php;</title> <varlistentry> <term><link linkend="reserved.variables.globals">$GLOBALS</link></term> <listitem> @@ -226,7 +236,7 @@ <varname>$_SERVER</varname>. La pr&eacute;sence et la valeur des entr&eacute;es de ce tableau sont r&eacute;gl&eacute;s par la directive <link linkend="ini.variables-order">variables_order</link>. Ce tableau - n'est l'&eacute;volution d'aucune variable d'avant PHP 4.1.0. + n'est l'&eacute;volution d'aucune variable d'avant &php; 4.1.0. </simpara> </listitem> </varlistentry> @@ -244,473 +254,25 @@ </varlistentry> </variablelist> </sect1> - - <sect1 id="language.variables.old"> - <title>Missing title</title> - <warning> - <simpara> - Cette section est la documentation qui avait cours jusqu'en PHP - version 4.1.2. Elle est laiss&eacute;e ici pour assurer la transition - avec les nouvelles versions, qui ont <emphasis>abandonn&eacute; d&eacute;finitivement</emphasis> - leur usage. Nous recommandons vivement au lecteur la - <link linkend="language.variables.superglobals">section pr&eacute;c&eacute;dente</link>. - </simpara> - <simpara> - Pour assurer une meilleure compatibilit&eacute; de vos scripts avec - les nouvelles versions de PHP, n'utilisez plus ces variables. - </simpara> - </warning> - <simpara> - Malgr&eacute; ces donn&eacute;es, voici une liste de variables - pr&eacute;d&eacute;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&egrave;te des variables pr&eacute;d&eacute;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&ccedil;u des variables pr&eacute;d&eacute;finies qui - peuvent &ecirc;tre accessibles dans les scripts. - </simpara> - </note> - <sect2 id="language.variables.predefined.apache"> - <title>Variables Apache</title> - <simpara> - Ces variables sont cr&eacute;&eacute;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&ecirc;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 &agrave; les retrouver. - </simpara> - <simpara> - Notez que peu d'entre elles seront accessibles lorsque PHP est appel&eacute; - en ligne de commande, (et elles n'auront alors peut &ecirc;tre pas de sens) - </simpara> - <para> - <variablelist> - <varlistentry> - <term>$GATEWAY_INTERFACE</term> - <listitem> - <simpara> - Num&eacute;ro de r&eacute;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&ocirc;te qui &eacute;x&eacute;cute le script suivant. - Si le script est ex&eacute;cut&eacute; sur un h&ocirc;te virtuel, ce sera - la valeur d&eacute;finie pour cet h&ocirc;te virtuel. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$SERVER_SOFTWARE</term> - <listitem> - <simpara> - Cha&icirc;ne d'identification du serveur, qui est donn&eacute;e dans - les en-t&ecirc;tes lors de la r&eacute;ponse aux requ&ecirc;tes. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$SERVER_PROTOCOL</term> - <listitem> - <simpara> - Nom et r&eacute;vision du protocole de communication : i.e. 'HTTP/1.0'; - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$REQUEST_METHOD</term> - <listitem> - <simpara> - M&eacute;thode de requ&ecirc;te utilis&eacute;e pour acc&eacute;der - &agrave; la page; i.e. 'GET', 'HEAD', 'POST', 'PUT'. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$QUERY_STRING</term> - <listitem> - <simpara> - La cha&icirc;ne de requ&ecirc;te, si elle existe, qui est - utilis&eacute;e pour acc&eacute;der &agrave; la page. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$DOCUMENT_ROOT</term> - <listitem> - <simpara> - La racine sous laquelle le script courant est ex&eacute;cut&eacute;, - comme d&eacute;fini dans la configuration du serveur. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_ACCEPT</term> - <listitem> - <simpara> - Contenu de l'en-t&ecirc;te <literal>Accept:</literal> de la - requ&ecirc;te courante, s'il y en a une. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_ACCEPT_CHARSET</term> - <listitem> - <simpara> - Contenu de l'en-t&ecirc;te <literal>Accept-Charset:</literal> - de la requ&ecirc;te courante, s'elle existe. Par exemple : - '<literal>iso-8859-1,*,utf-8</literal>'. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_ACCEPT_ENCODING</term> - <listitem> - <simpara> - Contenu de l'en-t&ecirc;te <literal>Accept-Encoding:</literal> - de la requ&ecirc;te courante, si elle existe. Par exemple : 'gzip'. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_ACCEPT_LANGUAGE</term> - <listitem> - <simpara> - Contenu de l'en-t&ecirc;te <literal>Accept-Language:</literal> de - la requ&ecirc;te courante, si elle existe. Par exemple : 'en'. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_CONNECTION</term> - <listitem> - <simpara> - Contenu de l'en-t&ecirc;te <literal>Connection:</literal> de la - requ&ecirc;te courante, si elle existe. Par exemple : 'Keep-Alive'. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_HOST</term> - <listitem> - <simpara> - Contenu de l'en-t&ecirc;te <literal>Host:</literal> de la - requ&ecirc;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 &agrave; la page courante. Cette valeur est - affect&eacute;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'en-t&ecirc;te <literal>User_Agent:</literal> de - la requ&ecirc;te courante, si elle existe. C'est une cha&icirc;ne - qui d&eacute;crit le client HTML utilis&eacute; 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 - en fonction des capacit&eacute;s du client. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$REMOTE_ADDR</term> - <listitem> - <simpara> - L'adresse IP du client qui demande la page courante. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$REMOTE_PORT</term> - <listitem> - <simpara> - Le port utilis&eacute; par la machine cliente pour communiquer - avec le serveur web. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$SCRIPT_FILENAME</term> - <listitem> - <simpara> - Le chemin absolu jusqu'au script courant. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$SERVER_ADMIN</term> - <listitem> - <simpara> - La valeur donn&eacute;e &agrave; la directive SERVER_ADMIN - (pour Apache), dans le fichier de configuration. Si le script - est ex&eacute;cut&eacute; par un h&ocirc;te virtuel, ce sera la - valeur d&eacute;finie par l'h&ocirc;te virtuel. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$SERVER_PORT</term> - <listitem> - <simpara> - Le port de la machine serveur utilis&eacute; pour les - communications. Par d&eacute;faut, c'est '80'. En utilisant - SSL, par exemple, il sera remplac&eacute; par le num&eacute;ro - de port HTTP s&eacute;curis&eacute;. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$SERVER_SIGNATURE</term> - <listitem> - <simpara> - Cha&icirc;ne contenant le num&eacute;ro de version du serveur - et le nom d'h&ocirc;te virtuel, qui sont ajout&eacute;s aux - pages g&eacute;n&eacute;r&eacute;es par le serveur, si cette - option est activ&eacute;e. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$PATH_TRANSLATED</term> - <listitem> - <simpara> - Chemin dans le syst&egrave;me de fichier (pas le document root-) - jusqu'au script courant, une fois que le serveur a fait - une chemin traduction virtuel->r&eacute;el. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$SCRIPT_NAME</term> - <listitem> - <simpara> - Contient le nom du script courant. Cela sert lorsque - les pages doivent s'appeler elles-m&ecirc;mes. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$REQUEST_URI</term> - <listitem> - <simpara> - L'URI qui a &eacute;t&eacute; fourni pour acc&eacute;der - &agrave; cette page. Par exemple : '/index.html'. - </simpara> - </listitem> - </varlistentry> - </variablelist> - </para> - </sect2> - <sect2 id="language.variables.predefined.environment"> - <title>Variables d'environnement</title> - <simpara> - Ces variables sont import&eacute;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&eacute;cute PHP et - diff&eacute;rents syst&egrave;mes &eacute;tant susceptibles - de disposer de diff&eacute;rents shells, une liste d&eacute;finitive - est impossible &agrave; &eacute;tablir. Reportez-vous &agrave; la - documentation de votre shell, pour conna&icirc;tre la liste des - variables d'environnement pr&eacute;d&eacute;finies. - </simpara> - <simpara> - Les autres variables d'environment incluent les variables CGI, - plac&eacute;es ici, quelquefois la m&eacute;thode - d'&eacute;x&eacute;cution de PHP (CGI ou module). - </simpara> - </sect2> - <sect2 id="language.variables.predefined.php"> - <title>Variables PHP</title> - <simpara> - Ces variables sont cr&eacute;&eacute;es par PHP lui_m&ecirc;me. - Les variables <varname>$HTTP_*_VARS</varname> ne sont disponibles - que si l'option de configuration - <link linkend="ini.track-vars">track_vars</link> a - &eacute;t&eacute; activ&eacute;e. Lorsque c'est le cas, ces variables - existent toujours, m&ecirc;me si ce sont des tableaux vides. Cela &eacute;vite les - usurpations mal intentionn&eacute;es de ces variables. - </simpara> - <note> - <para> - Depuis PHP 4.0.3, - <link linkend="ini.track-vars">track_vars</link> est toujours - activ&eacute;, quelle que soit la configuration. - </para> - </note> - <para> - Si la directive - <link linkend="ini.register-globals">register_globals</link> est activ&eacute;e, - alors ces variables seront aussi disponibles comme variables - globales du script : c'est-&agrave;-dire, ind&eacute;pendamment des tableaux - <varname>$HTTP_*_VARS</varname>. Cette fonctionnalit&eacute; - doit &ecirc;tre utilis&eacute;e avec pr&eacute;cautions, et de - pr&eacute;f&eacute;rence, d&eacute;sactiv&eacute;e. - Si <varname>$HTTP_*_VARS</varname> est s&eacute;curis&eacute;, - les &eacute;quivalents globaux peuvent &ecirc;tre &eacute;cras&eacute;s - par les donn&eacute;es d'entr&eacute;e de l'utilisateur, - avec des intrusions possibles. Si vous ne pouvez pas d&eacute;sactiver - <link linkend="ini.register-globals">register_globals</link>, vous - devez prendre toutes les dispositions possibles pour vous assurer - que les donn&eacute;es utilis&eacute;es sont s&ucirc;res. - </para> - <para> - <variablelist> - <varlistentry> - <term>$argv</term> - <listitem> - <simpara> - Tableau des arguments pass&eacute;es au script. Lorsque le script - est appel&eacute; en ligne de commande, cela donne acc&egrave;s - aux arguments, comme en langage C. Lorsque le script est - appel&eacute; avec la m&eacute;thode GET, ce tableau contiendra - la cha&icirc;ne de requ&ecirc;te. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$argc</term> - <listitem> - <simpara> - Contient le nombre de param&egrave;tres de la ligne de commande - pass&eacute;s au script (si le script fonctionne en ligne de commande). - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$PHP_SELF</term> - <listitem> - <simpara> - Le nom du fichier du script en cour d'&eacute;x&eacute;cution, par - rapport au document root. Si PHP fonctionne en ligne de commande, - cette variable n'est pas disponible. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_COOKIE_VARS</term> - <listitem> - <simpara> - Un tableau associatif des variables pass&eacute;es au script - courant via les HTTP cookies. Uniquement possible si le suivi - des variables a &eacute;t&eacute; activ&eacute; avec - la directive g&eacute;n&eacute;rale - <link linkend="ini.track-vars">track_vars</link> ou - avec la directive locale - <computeroutput>&lt;? php_track_vars ?&gt;</computeroutput>. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_GET_VARS</term> - <listitem> - <simpara> - Un tableau associatif des variables pass&eacute;es au script - courant via les HTTP GET. Uniquement possible si le suivi des - variables a &eacute;t&eacute; activ&eacute; avec la directive - g&eacute;n&eacute;rale - <link linkend="ini.track-vars">track_vars</link> ou - avec la directive locale - <computeroutput>&lt;? php_track_vars ?&gt;</computeroutput>. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_POST_VARS</term> - <listitem> - <simpara> - Un tableau associatif des variables pass&eacute;es au script - courant via les HTTP POST. Uniquement possible si le suivi des - variables a &eacute;t&eacute; activ&eacute; avec la directive - g&eacute;n&eacute;rale - <link linkend="ini.track-vars">track_vars</link> ou - avec la directive locale - <computeroutput>&lt;? php_track_vars ?&gt;</computeroutput>. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_POST_FILES</term> - <listitem> - <simpara> - Un tableau associatif contenant les informations sur les - fichiers t&eacute;l&eacute;charg&eacute;s avec la m&eacute;thode - HTTP POST. Reportez-vous au chapitre - <link linkend="features.file-upload.post-method"> - T&eacute;l&eacute;chargement par m&eacute;thode POST</link> - pour plus de d&eacute;tails sur le contenu de - <varname>$HTTP_POST_FILES</varname>. - </simpara> - <para> - <varname>$HTTP_POST_FILES</varname> n'est disponible que dans - les versions 4.0.0 et plus r&eacute;centes de PHP. - </para> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_ENV_VARS</term> - <listitem> - <simpara> - Un tableau associatif des variables pass&eacute;es au script - par l'environnement parent. - </simpara> - </listitem> - </varlistentry> - <varlistentry> - <term>$HTTP_SERVER_VARS</term> - <listitem> - <simpara> - Un tableau associatif des variables pass&eacute;es au script - par le serveur HTTP. Ces variables sont analogues - aux variables d&eacute;crites ci-dessus. - </simpara> - </listitem> - </varlistentry> - </variablelist> - </para> - </sect2> - </sect1> <sect1 id="language.variables.scope"> <title>Port&eacute;e des variables</title> <simpara> La port&eacute;e d'une variable d&eacute;pend du contexte dans lequel la variable est d&eacute;finie. Pour la majorit&eacute; des variables, la port&eacute;e concerne la totalit&eacute; d'un script - PHP. Mais, lorsque vous d&eacute;finissez une fonction, la + &php;. Mais, lorsque vous d&eacute;finissez une fonction, la port&eacute;e d'une variable d&eacute;finie dans cette fonction est locale &agrave; la fonction. Par exemple: </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $a = 1; include "b.inc"; -?&gt; +?> +]]> + </programlisting> </informalexample> <simpara> @@ -723,13 +285,16 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $a = 1; /* port&eacute;e globale */ function test() { echo $a; /* port&eacute;e locale */ } test(); -?&gt; +?> +]]> + </programlisting> </informalexample> <simpara> @@ -742,14 +307,15 @@ les fonctions, &agrave; moins d'&ecirc;tre red&eacute;finie localement dans la fonction. Cela peut poser des probl&egrave;mes si vous red&eacute;finissez des variables globales localement. - En PHP, une variable globale doit &ecirc;tre + En &php;, une variable globale doit &ecirc;tre d&eacute;clar&eacute;e &agrave; l'int&eacute;rieur de chaque fonction afin de pouvoir &ecirc;tre utilis&eacute;e dans cette fonction. Par exemple: </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $a = 1; $b = 2; function somme() { @@ -758,10 +324,11 @@ } somme(); echo $b; +]]> </programlisting> </informalexample> <simpara> - Le script ci-dessus va afficher la valeur &quot;3&quot;. + Le script ci-dessus va afficher la valeur <literal>3</literal>. En d&eacute;clarant globales les variables $a et $b locales de la fonction somme(), toutes les r&eacute;f&eacute;rences &agrave; ces variables concerneront les variables globales. Il n'y a @@ -777,15 +344,18 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php -$a = 1; -$b = 2; -function somme() { +<![CDATA[ +<?php + $a = 1; + $b = 2; + function somme() { $GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"]; -} -somme(); -echo $b; -?&gt; + } + somme(); + echo $b; +?> +]]> + </programlisting> </informalexample> <simpara> @@ -801,13 +371,16 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function test() { $a = 0; echo $a; $a++; } -?&gt; +?> +]]> + </programlisting> </informalexample> <simpara> @@ -822,13 +395,16 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function test() { static $a = 0; echo $a; $a++; } -?&gt; +?> +]]> + </programlisting> </informalexample> <simpara> @@ -848,17 +424,20 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php function test() { static $count = 0; $count++; echo $count; - if ($count &lt; 10) { + if ($count < 10) { test(); } $count--; } -?&gt; +?> +]]> + </programlisting> </informalexample> </sect1> @@ -872,9 +451,12 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $a = "bonjour"; -?&gt; +?> +]]> + </programlisting> </informalexample> <simpara> @@ -886,21 +468,27 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $$a = "monde"; -?&gt; +?> +]]> + </programlisting> </informalexample> <simpara> A ce niveau, deux variables ont &eacute;t&eacute; d&eacute;finies et - stock&eacute;es dans l'arbre des symboles PHP: $a avec comme valeur + stock&eacute;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"> -&lt;?php +<![CDATA[ +<?php echo "$a ${$a}"; -?&gt; +?> +]]> + </programlisting> </informalexample> <simpara> @@ -908,9 +496,12 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php echo "$a $bonjour"; -?&gt; +?> +]]> + </programlisting> </informalexample> <simpara> @@ -927,11 +518,11 @@ </simpara> </sect1> <sect1 id="language.variables.external"> - <title>Variables externes &agrave; PHP</title> + <title>Variables externes &agrave; &php;</title> <sect2 id="language.variables.external.form"> <title>Formulaires HTML (GET et POST)</title> <simpara> - Lorsqu'un formulaire est envoy&eacute; &agrave; un script PHP, + Lorsqu'un formulaire est envoy&eacute; &agrave; un script &php;, toutes les variables du formulaire seront automatiquement disponibles dans le script. Par exemple, consid&eacute;rons le formulaire suivant: </simpara> @@ -939,15 +530,17 @@ <example> <title>Exemple avec un formulaire simple</title> <programlisting role="html"> -&lt;form action="foo.php" method="post"&gt; - Nom: &lt;input type="text" name="nom"&gt;&lt;br&gt; - &lt;input type="submit"&gt; -&lt;/form> +<![CDATA[ +<form action="foo.php" method="post"> + Nom: <input type="text" name="nom"><BR> + <input type="submit"> +</form> +]]> </programlisting> </example> </para> <simpara> - Lorsque ce formulaire est envoy&eacute;, le PHP va cr&eacute;er la variable + Lorsque ce formulaire est envoy&eacute;, le &php; va cr&eacute;er la variable <computeroutput>$nom</computeroutput>, qui contiendra la valeur que vous avez entr&eacute;e dans le champs <emphasis>Nom:</emphasis> du formulaire. @@ -967,7 +560,7 @@ </para> </note> <simpara> - Le PHP permet aussi l'utilisation des tableaux dans le contexte de + Le &php; permet aussi l'utilisation des tableaux dans le contexte de formulaire, mais seulement des tableaux &agrave; une seule dimension. Comme cela, vous pouvez rassembler des variables ou utiliser cette fonctionnalit&eacute; pour r&eacute;cup&eacute;rer les valeurs d'un choix @@ -977,17 +570,19 @@ <example> <title>Variables complexes de formulaire</title> <programlisting role="html"> -&lt;form action="array.php" method="post"&gt; - Name: &lt;input type="text" name="personal[name]"&gt;&lt;br&gt; - Email: &lt;input type="text" name="personal[email]"&gt;&lt;br&gt; - Beer: &lt;br&gt; - &lt;select multiple name="vin[]"&gt; - &lt;option value="medoc"&gt;M&eacute;doc - &lt;option value="chablis"&gt;Chablis - &lt;option value="riesling"&gt;Riesling - &lt;/select&gt; - &lt;input type="submit"&gt; -&lt;/form&gt; +<![CDATA[ +<form action="array.php" method="post"> + Name: <input type="text" name="personal[name]"><br> + Email: <input type="text" name="personal[email]"><br> + Beer: <br> + <select multiple name="vin[]"> + <option value="medoc">M&eacute;doc + <option value="chablis">Chablis + <option value="riesling">Riesling + </select> + <input type="submit"> +</form> +]]> </programlisting> </example> </para> @@ -995,7 +590,11 @@ Si l'option "track_vars" est activ&eacute;e, soit par l'option de compilation <link linkend="ini.track-vars">track_vars</link>, soit par la directive de - configuration <computeroutput>&lt;? php_track_vars ?&gt;</computeroutput>, + configuration <computeroutput> +<![CDATA[ + <? php_track_vars ?> +]]> +</computeroutput>, les variables transmises par les m&eacute;thodes POST et GET pourront aussi &ecirc;tre trouv&eacute;es dans le tableau associatif global $HTTP_POST_VARS ou $HTTP_GET_VARS @@ -1010,7 +609,9 @@ </simpara> <informalexample> <programlisting role="html"> -&lt;input type=image src="image.gif" name="sub"&gt; +<![CDATA[ + <input type=image src="image.gif" name="sub"> +]]> </programlisting> </informalexample> <simpara> @@ -1020,7 +621,7 @@ de l'endroit o&ugrave; l'utilisateur &agrave; cliqu&eacute;. Les utilisateurs exp&eacute;riment&eacute;s remarqueront que les noms de variables sont transmis avec une virgule &agrave; la place du - caract&egrave;re "_", mais le PHP fait la conversion + caract&egrave;re "_", mais &php; fait la conversion automatiquement. </simpara> </sect3> @@ -1028,7 +629,7 @@ <sect2 id="language.variables.external.cookies"> <title>HTTP Cookies</title> <simpara> - Le PHP supporte les cookies HTTP de mani&egrave;re totalement + &php; supporte les cookies HTTP de mani&egrave;re totalement transparente, comme d&eacute;fini dans les <ulink url="&spec.cookies;">Netscape's Spec</ulink>. Les cookies sont un m&eacute;canisme permettant de stocker des donn&eacute;es @@ -1051,9 +652,12 @@ </simpara> <informalexample> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php setcookie ("MonCookie[]", "test", time()+3600); -?&gt; +?> +]]> + </programlisting> </informalexample> <simpara> @@ -1066,51 +670,30 @@ <example> <title>Exemple avec <function>setcookie</function></title> <programlisting role="php"> -&lt;?php +<![CDATA[ +<?php $compte++; SetCookie ("Compte", $compte, time()+3600); SetCookie ("Caddie[$compte]", $item, time()+3600); -?&gt; +?> +]]> + </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. - <informalexample> - <programlisting role="php"> -&lt;?php -echo $HOME; /* Affiche la valeur de la variable d'environnement HOME, - si celle-ci est affect&eacute;e. */ -?&gt; - </programlisting> - </informalexample> - </para> - <para> - M&ecirc;me si le PHP cr&eacute;e les variables lors de l'utilisation - des m&eacute;thodes GET, POST et cookie, il est de temps en temps - pr&eacute;f&eacute;rable de transmettre explicitement la valeur de - la variable afin d'&ecirc;tre s&ucirc;r de la valeur. - La fonction <function>getenv</function> peut &ecirc;tre - utilis&eacute;e pour r&eacute;cup&eacute;rer la valeur - des variables d'environnement. Vous pouvez aussi affecter - une variable d'environnement gr&acirc;ce &agrave; 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 + Typiquement, &php; ne modifie pas les noms des variables lorsqu'elles sont pass&eacute;es &agrave; un script. Cependant, il faut noter que les points (.) ne sont pas autoris&eacute;s dans les noms de variables - PHP. Pour cette raison, jetez un oeil sur : + &php;. Pour cette raison, jetez un oeil sur : <programlisting role="php"> -&lt;?php -$varname.ext; /* nom de variable invalide */ -?&gt; +<![CDATA[ +<?php + $varname.ext; /* nom de variable invalide */ +?> +]]> </programlisting> Dans ce cas, l'analyseur croit voir la variable nomm&eacute;e $varname, suivie par l'op&eacute;rateur de concat&eacute;nation, @@ -1119,7 +702,7 @@ particuli&egrave;re). Visiblement, ce n'est pas ce qu'on attendait... </para> <para> - Pour cette raison, il est important de noter que PHP remplacera + Pour cette raison, il est important de noter que &php; remplacera automatiquement les points des noms de variables entrantes par des soulign&eacute;s (underscore). </para> @@ -1127,10 +710,10 @@ <sect2 id="language.variables.determining-type-of"> <title>D&eacute;termination du type des variables</title> <para> - Parceque le PHP d&eacute;termine le type des variables et + Parceque &php; d&eacute;termine le type des variables et les convertit (g&eacute;n&eacute;ralement) comme il faut, ce n'est pas toujours le type de variable que vous souhaitez. - PHP inclut des fonctions permettant de d&eacute;terminer le + &php; inclut des fonctions permettant de d&eacute;terminer le type d'une variable : <function>gettype</function>, <function>is_long</function>,
« previous php.doc.fr (#192) next »