<?xml version="1.0" encoding="iso-8859-1"?>
<reference id="ref.strings">
 <title>Cha&icirc;ne de caract&egrave;res</title>
 <titleabbrev>Cha&icirc;nes</titleabbrev>
 <partintro>
  <simpara>
   Ces fonctions permettent la manipulation de cha&icirc;nes de
   caract&egrave;res. Certaines sections plus sp&eacute;cialis&eacute;es
   sont disponibles d&egrave;s les sections sur les expressions
   r&eacute;guli&egrave;res et dans la section URL.
  </simpara>
  <para>
   Pour plus de d&eacute;tails sur le comportement des cha&icirc;nes de caract&egrave;res,
   notamment concernant les guillemets simples ou doubles, et les
   s&eacute;quences d'&eacute;chappement, reportez-vous &agrave;
   <link linkend="language.types.string">cha&icirc;nes de caract&egrave;res</link>,
   dans le chapitre <link linkend="language.types">Types</link>.
  </para>
 </partintro>
 <refentry id="function.addcslashes">
  <refnamediv>
   <refname>AddCSlashes</refname>
   <refpurpose>
    Ajoute des slash dans une cha&icirc;ne, comme en langage C.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>addcslashes</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
     <methodparam><type>string</type><parameter>charlist</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>addcslashes</function> retourne une cha&icirc;ne avec des
    antislash devant les caract&egrave;res
    qui sont dans la liste <parameter>charlist</parameter>. Les caract&egrave;res
    <literal>&#92;n</literal>, <literal>&#92;r</literal> etc... sont &eacute;chapp&eacute;s.
    En langage C, les caract&egrave;res avec un code ASCII inf&eacute;rieur
    &agrave; 32 ou sup&eacute;rieur &agrave; 126 sont convertis en
    repr&eacute;sentation octale. Faites bien attention lorsque vous
    &eacute;chappez des caract&egrave;res alpha-num&eacute;riques.
    Vous pouvez sp&eacute;cifier un intervalle dans <parameter>charlist</parameter>
    comme "&#92;0..&#92;37", qui &eacute;chappera les caract&egrave;res compris
    dans cet intervalle.
    <example>
     <title>Exemple avec <function>addcslashes</function></title>
     <programlisting role="php">
&lt;?php
$escaped = addcslashes($no_echappe, &quot;&#92;0..&#92;37!@&#92;177..&#92;377&quot;);
?&gt;
     </programlisting>
    </example>
    <note>
     <simpara>
      <function>addcslashes</function> a &eacute;t&eacute; ajout&eacute; en PHP
      4.0b3-dev.
     </simpara>
    </note>
   </para>
   <para>
    Voir aussi
    <function>stripcslashes</function>,
    <function>stripslashes</function>,
    <function>htmlspecialchars</function> et
    <function>quotemeta</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.addslashes">
  <refnamediv>
   <refname>AddSlashes</refname>
   <refpurpose>
    Ajoute un slash devant tous les caract&egrave;res sp&eacute;ciaux.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>addslashes</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>addslashes</function> retourne une cha&icirc;ne avec
    des antislash devant chaque
    caract&egrave;re qui a en a besoin pour &ecirc;tre ins&eacute;r&eacute;
    dans une requ&ecirc;te de base de donn&eacute;es. Ces caract&egrave;res sont
    guillemets simples (<literal>'</literal>), guillemets doubles
    (<literal>"</literal>), antislash (<literal>&#92;</literal>) et &null;
    (la valeur nulle).
   </para>
   <para>
    Voir aussi
    <function>stripslashes</function>,
    <function>htmlspecialchars</function> et
    <function>quotemeta</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.bin2hex">
  <refnamediv>
   <refname>bin2hex</refname>
   <refpurpose>
    Convertit une valeur binaire en hexad&eacute;cimale
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>bin2hex</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>bin2hex</function> retourne une cha&icirc;ne ASCII
    contenant la repr&eacute;sentation
    hexad&eacute;cimale de <parameter>str</parameter>. La conversion est
    faite avec le bit de poids fort en premier.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.chop">
  <refnamediv>
   <refname>chop</refname>
   <refpurpose>
    Enl&egrave;ve les espaces de fin de cha&icirc;ne.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>chop</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>chop</function> retourne l'argument sans les espaces de
    fin de cha&icirc;ne.
    <example>
     <title>Exemple avec <function>chop</function></title>
     <programlisting role="php">
&lt;?php
  $trimmed = chop($line);
?&gt;
     </programlisting>
    </example>
   </para>
   <note>
    <para>
     <function>chop</function> diff&egrave;re de sa cousine Perl
     <literal>chop()</literal>, qui supprime le dernier caract&egrave;re
     de la cha&icirc;ne.
    </para>
   </note>
   <para>
    Voir aussi
    <function>trim</function>,
    <function>ltrim</function>,
    <function>rtrim</function> et
    <function>chop</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.chr">
  <refnamediv>
   <refname>chr</refname>
   <refpurpose>Retourne un caract&egrave;re.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>chr</methodname>
     <methodparam><type>int</type><parameter>ascii</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>chr</function> retourne le caract&egrave;re de code ASCII
    <parameter>ascii</parameter>.
    <example>
     <title>Exemple avec <function>chr</function></title>
     <programlisting role="php">
&lt;?php
$str .= chr(27); /* ajoute un &eacute;chappement &agrave; la fin de la cha&icirc;ne $str */
/* G&eacute;n&eacute;ralement, ceci est plus efficace  */
$str = sprintf("Cette cha&icirc;ne se termine par un &eacute;chappement : %c", 27);
?&gt;
     </programlisting>
    </example>
    <function>chr</function> est le contraire de <function>ord</function>.
   </para>
   <para>
    Voir aussi
    <function>sprintf</function>
    avec le format de cha&icirc;ne <literal>%c</literal>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.chunk-split">
  <refnamediv>
   <refname>chunk_split</refname>
   <refpurpose>Scinde une cha&icirc;ne en plus petits morceaux.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>chunk_split</methodname>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>chunklen</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>end</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>chunk_split</function> permet de scinder une cha&icirc;ne en
    plus petit morceaux, comme dans le cas de la conversion en
    <link linkend="function.base64-encode">base64_encode</link> pour se
    conformer &agrave; la RFC 2045.  <function>chunk_split</function>
    ins&egrave;re une fin de cha&icirc;ne <parameter>end</parameter>
    (par d&eacute;faut "&#92;r&#92;n"), tous les <parameter>chunklen</parameter>
    (par d&eacute;faut 76) caract&egrave;res. La cha&icirc;ne
    retourn&eacute;e est une nouvelle cha&icirc;ne, et
    l'original n'est pas modifi&eacute;.
    <example>
     <title>Exemple avec <function>chunk_split</function></title>
     <programlisting role="php">
&lt;?php
# formate $data avec la s&eacute;mantique RFC 2045
$new_string = chunk_split(base64_encode($data));
?&gt;
     </programlisting>
    </example>
    <function>chunk_split</function> est nettement plus rapide que
    <function>ereg_replace</function>.
    <note>
     <para>
      <function>chunk_split</function> a &eacute;t&eacute; ajout&eacute;e en 3.0.6.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.convert-cyr-string">
  <refnamediv>
   <refname>convert_cyr_string</refname>
   <refpurpose>
    Convertit la cha&icirc;ne d'un alphabet cyrillique vers un autre.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>convert_cyr_string</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
     <methodparam><type>string</type><parameter>from</parameter></methodparam>
     <methodparam><type>string</type><parameter>to</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>convert_cyr_string</function> convertit la cha&icirc;ne
    donn&eacute;e depuis un alphabet cyrillique vers un autre. Les
    arguments <parameter>from</parameter> et <parameter>to</parameter>
    sont des caract&egrave;res qui repr&eacute;sentent la source et
    la destination. Les valeurs accept&eacute;es :
    <itemizedlist>
     <listitem>
      <simpara>
       k - koi8-r
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       w - windows-1251
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       i - iso8859-5
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       a - x-cp866
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       d - x-cp866
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       m - x-mac-cyrillic
      </simpara>
     </listitem>
    </itemizedlist>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.count-chars">
  <refnamediv>
   <refname>count_chars</refname>
   <refpurpose>
    Retourne des informations sur les caract&egrave;res utilis&eacute;s dans
    une cha&icirc;ne.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>count_chars</methodname>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>mode</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>count_chars</function> compte le nombre d'occurrences de
    chaque octet (0..255) dans la cha&icirc;ne <parameter>string</parameter> et
    le retourne de diff&eacute;rentes fa&ccedil;ons. L'option
    <parameter>mode</parameter> prend, par d&eacute;faut,
    la valeur 0. Suivant le <parameter>mode</parameter>,
    <function>count_chars</function> retourne une des r&eacute;ponses suivantes :
    <itemizedlist>
     <listitem>
      <simpara>
       0 - Un tableau avec l'octet comme cl&eacute;, et la fr&eacute;quence comme valeur.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       1 - Identique &agrave; 0, mais seules les fr&eacute;quences non nulles sont
       list&eacute;es.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       2 - Identique &agrave; 0, mais seules les fr&eacute;quences nulles sont
       list&eacute;es.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       3 - Une cha&icirc;ne qui contient tous les octets utilis&eacute;s.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       4 - Une cha&icirc;ne contenant tous les octets non utilis&eacute;s.
      </simpara>
     </listitem>
    </itemizedlist>
   </para>
   <note>
    <para>
     <function>count_chars</function> a &eacute;t&eacute; ajout&eacute;e
     en PHP 4.0.
    </para>
   </note>
  </refsect1>
 </refentry>
 <refentry id="function.crc32">
  <refnamediv>
   <refname>crc32</refname>
   <refpurpose>Calcule le polyn&ocirc;me crc32 d'une cha&icirc;ne</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>crc32</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>crc32</function> g&eacute;n&egrave;re la somme de v&eacute;rification
    de redondances cycliques (32 bits) de la cha&icirc;ne <parameter>str</parameter>.
    Cette valeur sert g&eacute;n&eacute;ralement &agrave; v&eacute;rifier
    l'int&eacute;grit&eacute; de donn&eacute;es transmises.
   </para>
   <para>
    Voir aussi
    <function>md5</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.crypt">
  <refnamediv>
   <refname>crypt</refname>
   <refpurpose>Chiffre une cha&icirc;ne avec un DES.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>crypt</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>salt</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>crypt</function> va coder une cha&icirc;ne en utilisant la
    m&eacute;thode de chiffrage du <abbrev>DES</abbrev> standard. Les
    arguments sont : la cha&icirc;ne &agrave; chiffrer, et un grain de
    sel qui servira de base pour le chiffrement.
    Reportez-vous au manuel Unix pour plus de d&eacute;tails.
   </para>
   <simpara>
    Si le grain de sel n'est pas fourni, il sera automatiquement
    g&eacute;n&eacute;r&eacute; par PHP.
   </simpara>
   <simpara>
    Certains syst&egrave;mes d'exploitation acceptent plus d'un type de
    chiffrement.
    En fait, le DES standard est parfois remplac&eacute; par un chiffrement
    MD5.
    Le type de chiffrement est alors choisi en fonction du grain de sel.
    A l'installation, PHP d&eacute;termine les possibilit&eacute;s de cryptage et
    d&eacute;cidera d'accepter d'autres grains de sel pour d'autres types
    de chiffrement. Si le grain de sel n'est pas fourni, PHP g&eacute;n&egrave;rera
    alors un grain de 2 caract&egrave;res, pour le DES standard, &agrave; moins
    que le syst&egrave;me ne dispose de MD5 : dans ce cas, PHP
    g&eacute;n&egrave;rera un grain de sel pour MD, par d&eacute;faut.
    PHP affecte la variable d'environnement CRYPT_SALT_LENGTH, &agrave;
    2 s'il utilise le DES standard, et &agrave; 12 s'il utilise le MD5.
   </simpara>
   <simpara>
    Si vous utilisez le grain de sel fourni, retenez bien que ce grain
    de sel est g&eacute;n&eacute;r&eacute; une seule fois. Si vous appelez
    <function>crypt</function> r&eacute;cursivement, cela aura un impact sur
    l'apparence et finalement la s&eacute;curit&eacute; de votre cryptage.
   </simpara>
   <simpara>
    Le chiffrement standard fournit le grain de sel dans les deux premiers octets
    du r&eacute;sultat de la fonction <function>crypt</function>.
   </simpara>
   <simpara>
    Sur les syst&egrave;mes qui supportent plusieurs m&eacute;thodes
    de chiffrement, les variables d'environnement suivantes sont mises
    &agrave; 0 ou &agrave; 1, en fonction de la disponibilit&eacute;
    de la m&eacute;thode :
   </simpara>
   <itemizedlist>
    <listitem>
     <simpara>
      CRYPT_STD_DES - DES Standard avec 2-octets de SALT
     </simpara>
    </listitem>
    <listitem>
     <simpara>
      CRYPT_EXT_DES - DES &eacute;tendu avec 9-octets SALT
     </simpara>
    </listitem>
    <listitem>
     <simpara>
      CRYPT_MD5 - MD5 avec 12-octets SALT commen&ccedil;ant &agrave; $1$
     </simpara>
    </listitem>
    <listitem>
     <simpara>
      CRYPT_BLOWFISH - DES &eacute;tendu avec 16-octets SALT commen&ccedil;ant &agrave; $2$
     </simpara>
    </listitem>
   </itemizedlist>
   <simpara>
    Il n'y a pas d'algorithme de d&eacute;cryptage, &eacute;tant donn&eacute; que
    <function>crypt</function> est injective.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.echo">
  <refnamediv>
   <refname>echo</refname>
   <refpurpose>Affiche une ou plusieurs cha&icirc;nes.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <methodname>echo</methodname>
     <methodparam><type>string</type><parameter>arg1</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>argn...</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>echo</function> affiche tous les param&egrave;tres.
   </simpara>
   <para>
    <function>echo</function> n'est pas une fonction &agrave; proprement
    parler, ce qui rend l'usage des parenth&egrave;ses facultatifs.
    En fait, si vous voulez passer plus d'un param&egrave;tre, vous ne devez
    pas utiliser les parenth&egrave;ses.
    <example>
     <title>Exemple avec <function>echo</function></title>
     <programlisting role="php">
&lt;?php
echo "Bonjour Monde";
echo "Cet echo() se
r&eacute;partit sur plusieurs lignes. Les nouvelles lignes
seront aussi affich&eacute;es";
echo "Cet echo() se&#92;nr&eacute;partit sur plusieurs lignes. Les nouvelles lignes&#92;nseront aussi affich&eacute;es.";
echo "L'&eacute;chappement de caract&egrave;res est fait : &#92;"comme ceci&#92;".";
//Vous pouvez utiliser des variables avec echo
$foo = "foobar";
$bar = "barbaz";
echo "foo vaut &amp;quot;$foo&amp;quot;";
// foo vaut "foobar"
// Les guillemets simples &eacute;vitent le remplacement des variables
echo 'foo is $foo'; // foo vaut $foo
// Si vous n'utilisez pas d'autres caract&egrave;res,
// vous ne ferez qu'afficher une variable
echo $foo;          // foobar
echo $foo,$bar;     // foobarbarbaz
// comme echo() n'est pas une fonction, le code suivant est invalide
($some_var) ? echo('Oui'): echo('Non');
// Cependant, les lignes suivantes sont valides :
($some_var) ? print('Oui'): print('Non'); // print est une fonction
echo ($some_var) ? 'Oui': 'Non';
?&gt;
     </programlisting>
    </example>
   </para>
   <simpara>
    Voir aussi :
    <function>print</function>,
    <function>printf</function> et
    <function>flush</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.explode">
  <refnamediv>
   <refname>explode</refname>
   <refpurpose>
    Scinde une cha&icirc;ne en morceaux, gr&acirc;ce &agrave; un d&eacute;limiteur.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>explode</methodname>
     <methodparam><type>string</type><parameter>separator</parameter></methodparam>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>limit</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>explode</function> retourne un tableau qui contient
    les &eacute;l&eacute;ments de la cha&icirc;ne
    <parameter>string</parameter>, s&eacute;par&eacute;s par
    <parameter>separator</parameter>. Si <parameter>limit</parameter>
    est fourni, le tableau retourn&eacute; contiendra un maximum de
    <parameter>limit</parameter> &eacute;l&eacute;ments, et le dernier
    &eacute;l&eacute;ments contiendra le reste de la cha&icirc;ne <parameter>string</parameter>.
    Si une cha&icirc;ne vide est utilis&eacute;e comme <parameter>separator</parameter>,
    alors <function>explode</function> retournera &false;.
    So <parameter>separator</parameter> contient une valeur qui n'est pas dans
    <parameter>string</parameter>, Alors  <function>explode</function>
    retournera la cha&icirc;ne <parameter>string</parameter>.
    <example>
     <title>Exemple avec <function>explode</function></title>
     <programlisting role="php">
&lt;?php
$pizza = "piece1 piece2 piece3 piece4 piece5 piece6";
$pieces = explode(" ", $pizza);
?&gt;
     </programlisting>
    </example>
   </para>
   <note>
    <para>
     Le param&egrave;tre <parameter>limit</parameter> a &eacute;t&eacute;
     ajout&eacute; en PHP 4.0.1.
    </para>
   </note>
   <note>
    <para>
     Bien que <function>implode</function> accepte, pour des raisons historiques,
     les arguments dans un sens ou l'autre, <function>explode</function>, lui,
     ne le peut pas. Vous devez vous assurer que l'argument s&eacute;parateur
     <parameter>separator</parameter> arrive avant l'argument de cha&icirc;ne.
    </para>
   </note>
   <para>
    Voir aussi
    <function>preg_split</function>,
    <function>spliti</function>,
    <function>split</function> et
    <function>implode</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.get-html-translation-table">
  <refnamediv>
   <refname>get_html_translation_table</refname>
   <refpurpose>
    Retourne la table de traduction HTML
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>get_html_translation_table</methodname>
     <methodparam><type>int</type><parameter>table</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>quote_style</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>get_html_translation_table</function> retourne la table de traduction
    utilis&eacute;e en interne par <function>htmlspecialchars</function> et
    <function>htmlentities</function>. Il y a deux nouvelles d&eacute;finitions :
    (<parameter>html_entities</parameter>, <parameter>html_specialchars</parameter>)
    qui vous permettent de sp&eacute;cifier vos propres tables.
    <example>
     <title>Exemple de table de traduction</title>
     <programlisting role="php">
&lt;?php
$trans = get_html_translation_table(HTML_ENTITIES);
$str = "Hallo &amp; &lt;Frau&gt; &amp; Kr&auml;mer";
$encoded = strtr($str, $trans);
?&gt;
     </programlisting>
    </example>
    La variable <literal>$encoded</literal> va contenir d&eacute;sormais : "Hallo
    &amp;<sgmltag>amp</sgmltag>; &amp;<sgmltag>lt</sgmltag>;Frau&amp;<sgmltag>gt</sgmltag>;
    &amp;<sgmltag>amp</sgmltag>; Kr&amp;<sgmltag>auml</sgmltag>;mer".
   </para>
   <para>
    <function>array_flip</function> est alors tr&egrave;s efficace pour inverser la
    direction de traduction :
    <informalexample>
     <programlisting role="php">
&lt;?php
$trans = array_flip($trans);
$original = strtr($str, $trans);
?&gt;
     </programlisting>
    </informalexample>
    Le contenu de <varname>$original</varname> sera :
    "<literal>Hallo &amp; &lt;Frau&gt; &amp; Kr&auml;mer</literal>".
    <note>
     <para>
      <function>get_html_translation_table</function> a &eacute;t&eacute;
      ajout&eacute;e en PHP 4.0.
     </para>
    </note>
   </para>
   <para>
    Voir aussi
    <function>htmlspecialchars</function>,
    <function>htmlentities</function>,
    <function>strtr</function> et
    <function>array_flip</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.get-meta-tags">
  <refnamediv>
   <refname>get_meta_tags</refname>
   <refpurpose>
    Extrait toutes les balises meta d'un fichier
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>get_meta_tags</methodname>
     <methodparam><type>string</type><parameter>filename</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>use_include_path</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>get_meta_tags</function> ouvre le fichier
    <parameter>filename</parameter> et l'analyse ligne par ligne,
    en recherchant les balises &lt;meta>.
    <example>
     <title>Exemple avec les balises m&eacute;ta</title>
     <programlisting role="html">
&lt;?php
&lt;meta name="author" content="name">
&lt;meta name="tags" content="php3 documentation">
&lt;/head> &lt;!-- parsing stops here -->
?&gt;
     </programlisting>
    </example>
    (Faites bien attention aux fins de ligne. PHP utilise une fonction
    native pour analyser le fichier d'entr&eacute;e, ce qui fait que les
    fichiers cr&eacute;&eacute;s sous MacOS ne fonctionneront pas sous Unix).
   </para>
   <para>
    Le nom d'une propri&eacute;t&eacute; devient sa cl&eacute;, et la
    valeur devient la valeur dans le tableau associatif retourn&eacute;,
    ce qui rend ais&eacute; la manipulation des informations. Les
    caract&egrave;res sp&eacute;ciaux dans le nom de la propri&eacute;t&eacute;
    sont remplac&eacute;s par des '_', le reste est converti en minuscules.
   </para>
   <para>
    Mettre <parameter>use_include_path</parameter> &agrave; 1 forcera PHP
    &agrave; ouvrir les fichiers dans le chemin standard d'inclusion.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.hebrev">
  <refnamediv>
   <refname>hebrev</refname>
   <refpurpose>
    Convertit un texte h&eacute;breux logique en texte visual
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>hebrev</methodname>
     <methodparam><type>string</type><parameter>hebrew_text</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>max_chars_per_line</parameter></methodparam>
    </methodsynopsis>
   <para>
    Le param&egrave;tre optionnel <parameter>max_chars_per_line</parameter>
    indique le nombre maximum de caract&egrave;res par ligne qui seront
    g&eacute;n&eacute;r&eacute;s. La fonction essaie d'&eacute;viter
    les c&eacute;sures de mots.
   </para>
   <para>
    Voir aussi
    <function>hebrevc</function>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.hebrevc">
  <refnamediv>
   <refname>hebrevc</refname>
   <refpurpose>
    Convertit un texte h&eacute;breux logique en texte visuel
    avec les nouvelles lignes de conversion.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>hebrevc</methodname>
     <methodparam><type>string</type><parameter>hebrew_text</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>max_chars_per_line</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>hebrevc</function> est similaire &agrave;
    <function>hebrev</function>, au d&eacute;tail pr&egrave;s
    qu'elle convertit les nouvelles lignes (<literal>&#92;n</literal>) en "&lt;br&gt;&#92;n".
    Le param&egrave;tre optionnel <parameter>max_chars_per_line</parameter>
    indique le nombre maximum de caract&egrave;res par ligne
    qui seront g&eacute;n&eacute;r&eacute;s. La fonction essaie
    d'&eacute;viter les c&eacute;sures de mots.
   </para>
   <para>
    Voir aussi
    <function>hebrev</function>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.htmlentities">
  <refnamediv>
   <refname>htmlentities</refname>
   <refpurpose>
    Convertit tous les caract&egrave;res sp&eacute;ciaux en entit&eacute; HTML.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>htmlentities</methodname>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>quote_style</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>htmlentities</function> est identique &agrave;
    <function>htmlspecialchars</function> en tous points, sauf que
    tous les caract&egrave;res qui ont une entit&eacute;
    &eacute;quivalente en HTML sont remplac&eacute;s par ces entit&eacute;s.
    Comme <function>htmlspecialchars</function>, elle prend un argument
    optionnel qui indique ce qui doit &ecirc;tre fait avec les guillemets
    simples et doubles. <constant>ENT_COMPAT</constant> (par d&eacute;faut)
    convertira les guillemets doubles, et ignorera les guillemets simples.
    <constant>ENT_QUOTES</constant> convertira les deux types de guillemets
    et <constant>ENT_NOQUOTES</constant> les ignorera tous les deux.
   </para>
   <para>
    Actuellement, le jeu de caract&egrave;res ISO-8859-1 est utilis&eacute;.
    Notez que l'argument optionnel a &eacute;t&eacute; ajout&eacute;
    PHP 3.0.17 et PHP 4.0.3.
   </para>
   <para>
    Voir aussi
    <function>htmlspecialchars</function> et
    <function>nl2br</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.htmlspecialchars">
  <refnamediv>
   <refname>htmlspecialchars</refname>
   <refpurpose>
    Convertit tous les caract&egrave;res sp&eacute;ciaux en entit&eacute; HTML.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>htmlspecialchars</methodname>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>quote_style</parameter></methodparam>
    </methodsynopsis>
   <para>
    Certains caract&egrave;res ont une valeur avec HTML, et doivent
    &ecirc;tre remplac&eacute;s par des balises HTML pour conserver
    leur valeur. <function>htmlspecialchars</function> retourne une
    cha&icirc;ne dont tous les caract&egrave;res sensibles ont
    &eacute;t&eacute; remplac&eacute;s par leur &eacute;quivalent.
   </para>
   <simpara>
    <function>htmlspecialchars</function> est utile pour emp&ecirc;cher
    un utilisateur de fournir un texte avec un sens HTML, comme dans
    un livre d'or.
   </simpara>
   <simpara>
    <function>htmlspecialchars</function> est pratique pour &eacute;viter que
    les textes fournis par les utilisateurs contiennent des balises HTML,
    comme dans le cas d'un livre d'or ou d'une tribune.
    <function>htmlspecialchars</function>
    prend un argument optionnel qui indique ce qui doit &ecirc;tre fait
    avec les guillemets simples et doubles. <constant>ENT_COMPAT</constant>
    (par d&eacute;faut) convertira les guillemets doubles, et ignorera
    les guillemets simples. <constant>ENT_QUOTES</constant> convertira
    les deux types de guillemets et <constant>ENT_NOQUOTES</constant>
    les ignorera tous les deux.
   </simpara>
   <para>
    Actuellement, PHP remplace les valeurs suivantes :
    <itemizedlist>
     <listitem>
      <simpara>
       '&amp;' (et commercial) devient '&amp;amp;'
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       '&quot;' (guillemet double) devient '&amp;quot;' si ENT_NOQUOTES n'est pas actif
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       '&#039;' (guillemet simple) devient '&amp;#039;' si ENT_QUOTES est actif
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       '&lt;' (inf&eacute;rieur &agrave;) devient '&amp;lt;'
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       '&gt;' (sup&eacute;rieur &agrave;) devient '&amp;gt;'
      </simpara>
     </listitem>
    </itemizedlist>
   </para>
   <example>
    <title>Exemple avec <function>htmlspecialchars</function></title>
    <programlisting role="php">
&lt;?php
$new = htmlspecialchars("&lt;a href='test'&gt;Test&lt;/A&gt;", ENT_QUOTES);
?&gt;
    </programlisting>
   </example>
   <para>
    Notez bien que <function>htmlspecialchars</function> ne fait aucun
    autre remplacement que ceux list&eacute;s ci-dessus. Pour une
    traduction compl&egrave;te de toutes les balises, reportez-vous &agrave;
    <function>htmlentities</function>.  Notez que l'argument optionnel
    a &eacute;t&eacute; ajout&eacute; PHP 3.0.17 et PHP 4.0.3.
   </para>
   <para>
    Voir aussi
    <function>htmlentities</function> et
    <function>nl2br</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.implode">
  <refnamediv>
   <refname>implode</refname>
   <refpurpose>
    Regroupe tous les &eacute;l&eacute;ments d'un tableau dans une
    cha&icirc;ne, avec une cha&icirc;ne de jointure.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>implode</methodname>
     <methodparam><type>string</type><parameter>glue</parameter></methodparam>
     <methodparam><type>array</type><parameter>pieces</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>implode</function> retourne une cha&icirc;ne
    constitu&eacute;e de tous les
    &eacute;l&eacute;ments du tableau, pris dans l'ordre,
    transform&eacute;s en cha&icirc;ne, et s&eacute;par&eacute;s par
    <parameter>glue</parameter>.
    <example>
     <title>Exemple avec <function>implode</function></title>
     <programlisting role="php">
&lt;?php
$colon_separated = implode(":", $array);
?&gt;
     </programlisting>
    </example>
   </para>
   <note>
    <para>
     Pour des raisons historiques, <function>implode</function> accepte
     ces arguments dans l'un ou l'autre sens. Par coh&eacute;rence avec la fonction
     <function>explode</function>, il est plus clair d'utiliser l'ordre
     des arguments tel que document&eacute;.
    </para>
   </note>
   <simpara>
    Voir aussi
    <function>explode</function>,
    <function>join</function> et
    <function>split</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.join">
  <refnamediv>
   <refname>join</refname>
   <refpurpose>
    Regroupe tous les &eacute;l&eacute;ments d'un tableau dans
    une cha&icirc;ne, avec une cha&icirc;ne de jointure.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>join</methodname>
     <methodparam><type>string</type><parameter>glue</parameter></methodparam>
     <methodparam><type>array</type><parameter>pieces</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>join</function> est un alias de <function>implode</function>,
    et lui est identique en tous points.
   </simpara>
   <simpara>
    Voir aussi
    <function>explode</function>,
    <function>implode</function> et
    <function>split</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.levenshtein">
  <refnamediv>
   <refname>levenshtein</refname>
   <refpurpose>
    Calcule la distance Levenshtein entre deux cha&icirc;nes
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>levenshtein</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
    </methodsynopsis>
    <methodsynopsis>
     <type>int</type><methodname>levenshtein</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
     <methodparam><type>int</type><parameter>cost_ins</parameter></methodparam>
     <methodparam><type>int</type><parameter>cost_rep</parameter></methodparam>
     <methodparam><type>int</type><parameter>cost_del</parameter></methodparam>
    </methodsynopsis>
    <methodsynopsis>
     <type>int</type><methodname>levenshtein</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
     <methodparam><type>function</type><parameter>cost</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>levenshtein</function> retourne la distance Levenshtein
    entre les deux cha&icirc;nes <parameter>str1</parameter> et
    <parameter>str1</parameter> ou -1 si un des arguments exc&egrave;de
    la limite de 255 caract&egrave;res.
   </para>
   <para>
    La distance Levenshtein est d&eacute;finie comme le nombre
    minimal de caract&egrave;res qu'il faut
    remplacer, ins&eacute;rer ou effacer pour transformer la
    cha&icirc;ne <parameter>str1</parameter> en <parameter>str2</parameter>.
    La complexit&eacute; de l'algorithme est en <literal>O(m*n)</literal>,
    o&ugrave; <literal>n</literal> et <literal>m</literal> sont les
    longueurs respectives de <parameter>str1</parameter> et
    <parameter>str2</parameter> (ceci est plut&ocirc;t un bon
    r&eacute;sultat, compar&eacute; &agrave; <function>similar_text</function>,
    qui est en O(max(n,m)**3), mais cela reste co&ucirc;teux en terme de ressources).
   </para>
   <para>
    Dans sa forme la plus simple, la fonction va prendre uniquement
    deux cha&icirc;nes en param&egrave;tres, et calculer uniquement le nombre
    d'insertions, remplacements et effacements n&eacute;cessaires pour transformer
    la cha&icirc;ne <parameter>str1</parameter> en <parameter>str2</parameter>.
   </para>
   <para>
    Une variante prend trois param&egrave;tres additionnels, qui d&eacute;finissent
    le co&ucirc;t des insertions, des remplacements et des effacement.
    C'est une version plus g&eacute;n&eacute;rale et plus souple que la version
    simple, mais qui n'est pas aussi efficace.
   </para>
   <para>
    La deuxi&egrave;me variante n'est pas encore impl&eacute;ment&eacute;e.
    Elle est encore plus g&eacute;n&eacute;rale, et plus souple, mais plus lente.
    Elle appellera une fonction utilisateur qui d&eacute;terminera le co&ucirc;t
    de chaque op&eacute;ration.
   </para>
   <para>
    La fonction utilisateur sera appel&eacute;e avec les arguments suivants :
    <itemizedlist>
     <listitem>
      <simpara>
       op&eacute;ration a appliquer : 'I', 'R' or 'D'
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       caract&egrave;re courant de la cha&icirc;ne <parameter>str1</parameter>
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       caract&egrave;re courant de la cha&icirc;ne <parameter>str2</parameter>
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       position courante de la cha&icirc;ne <parameter>str1</parameter>
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       position courante de la cha&icirc;ne <parameter>str2</parameter>
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       caract&egrave;res restants dans la cha&icirc;ne <parameter>str1</parameter>
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       caract&egrave;res restants dans la cha&icirc;ne <parameter>str2</parameter>
      </simpara>
     </listitem>
    </itemizedlist>
    La fonction utilisateur doit retourner un entier positif, qui
    d&eacute;crira le co&ucirc;t de cette op&eacute;ration particuli&egrave;re. Elle peut ne
    prendre en compte que certains arguments, et non leur
    totalit&eacute;.
   </para>
   <para>
    L'utilisation d'une fonction utilisateur permet de prendre en
    compte la diff&eacute;rence entre certains caract&egrave;res, ou
    leur contexte pour d&eacute;terminer le co&ucirc;t d'une op&eacute;ration
    d'insertion, remplacement ou effacement. Elle accro&icirc;t la charge de calcul
    demand&eacute;e au CPU, et annule l'optimisation des autres variantes.
   </para>
   <para>
    Voir aussi
    <function>soundex</function>,
    <function>similar_text</function> et
    <function>metaphone</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.localeconv">
  <refnamediv>
   <refname>localeconv</refname>
   <refpurpose>Lit le formatage num&eacute;rique et mon&eacute;taire</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>localeconv</methodname>
     <void/>
    </methodsynopsis>
   <para>
    <function>localeconv</function> retourne un tableau associatif contenant
    les informations locales de formats mon&eacute;taire et num&eacute;rique
    utilis&eacute;s par le serveur.
   </para>
   <para>
    <function>localeconv</function> retourne les informations &agrave;
    partir des donn&eacute;es locales, comme d&eacute;finies par
    <function>setlocale</function>. Le tableau associatif retourn&eacute;
    contient les entr&eacute;es suivantes :
    <informaltable >
    <tgroup cols="2">
     <thead>
     <row>
      <entry>Index</entry>
      <entry>Description</entry>
     </row>
     </thead>
     <tbody>
      <row>
       <entry>decimal_point</entry>
       <entry>S&eacute;parateur d&eacute;cimal</entry>
      </row>
      <row>
       <entry>thousands_sep</entry>
       <entry>S&eacute;parateur de milliers</entry>
      </row>
      <row>
       <entry>grouping</entry>
       <entry>Tableau contenant les groupages num&eacute;riques</entry>
      </row>
      <row>
       <entry>int_curr_symbol</entry>
       <entry>Symbole mon&eacute;taire international (i.e. FRF)</entry>
      </row>
      <row>
       <entry>currency_symbol</entry>
       <entry>Symbole mon&eacute;taire local (i.e. F)</entry>
      </row>
      <row>
       <entry>mon_decimal_point</entry>
       <entry>S&eacute;parateur d&eacute;cimal mon&eacute;taire</entry>
      </row>
      <row>
       <entry>mon_thousands_sep</entry>
       <entry>S&eacute;parateur de milliers mon&eacute;taires</entry>
      </row>
      <row>
       <entry>mon_grouping</entry>
       <entry>Tableau contenant les groupages num&eacute;riques mon&eacute;taires</entry>
      </row>
      <row>
       <entry>positive_sign</entry>
       <entry>Signe des valeurs positives</entry>
      </row>
      <row>
       <entry>negative_sign</entry>
       <entry>Signe des valeurs n&eacute;gatives</entry>
      </row>
      <row>
       <entry>int_frac_digits</entry>
       <entry>Nombre de chiffres d&eacute;cimaux international</entry>
      </row>
      <row>
       <entry>frac_digits</entry>
       <entry>Nombre de chiffres d&eacute;cimaux locaux</entry>
      </row>
      <row>
       <entry>p_cs_precedes</entry>
       <entry>&true; si currency_symbol pr&eacute;c&egrave;de une valeur positive,
       &false; s'il lui succ&egrave;de</entry>
      </row>
      <row>
       <entry>p_sep_by_space</entry>
       <entry>&true; si un espace s&eacute;pare currency_symbol d'une valeur positive,
       &false; sinon</entry>
      </row>
      <row>
       <entry>n_cs_precedes</entry>
       <entry>&true; si currency_symbol pr&eacute;c&egrave;de une valeur n&eacute;gative,
       &false; s'il lui succ&egrave;de</entry>
      </row>
      <row>
       <entry>n_sep_by_space</entry>
       <entry>&true; si un espace s&eacute;pare currency_symbol d'une valeur n&eacute;gative,
       &false; sinon</entry>
      </row>
      <row>
       <entry>p_sign_posn</entry>
       <entry>
        <simplelist columns="2" type="horiz">
        <member>0</member>
        <member>Des parenth&egrave;ses entourent la quantit&eacute; et currency_symbol</member>
        <member>1</member>
        <member>Le signe pr&eacute;c&egrave;de la quantit&eacute; et currency_symbol</member>
        <member>2</member>
        <member>Le signe suit la quantit&eacute; et currency_symbol</member>
        <member>3</member>
        <member>Le signe pr&eacute;c&egrave;de imm&eacute;diatement currency_symbol</member>
        <member>4</member>
        <member>Le signe suit imm&eacute;diatement currency_symbol</member>
        </simplelist>
       </entry>
      </row>
      <row>
       <entry>n_sign_posn</entry>
       <entry>
        <simplelist columns="2" type="horiz">
        <member>0</member>
        <member>Des parenth&egrave;ses entourent la quantit&eacute; et currency_symbol</member>
        <member>1</member>
        <member>Le signe pr&eacute;c&egrave;de la quantit&eacute; et currency_symbol</member>
        <member>2</member>
        <member>Le signe suit la quantit&eacute; et currency_symbol</member>
        <member>3</member>
        <member>Le signe pr&eacute;c&egrave;de imm&eacute;diatement currency_symbol</member>
        <member>4</member>
        <member>Le signe suit imm&eacute;diatement currency_symbol</member>
        </simplelist>
       </entry>
      </row>
     </tbody>
    </tgroup>
    </informaltable>
   </para>
   <para>
    Le champs de groupage contient un tableau qui d&eacute;finit comment les
    chiffres doivent &ecirc;tre regroup&eacute;s. Par exemple, ce champs pour
    le dollar am&eacute;ricain contient un tableau de deux &eacute;l&eacute;ments
    (3 et 3). Les &eacute;l&eacute;ments sont class&eacute;s de gauche &agrave; droite.
    Si un des &eacute;l&eacute;ments vaut CHAR_MAX, les groupages ne sont plus
    effectu&eacute;s. Si un &eacute;l&eacute;ments vaut 0, la valeur du
    pr&eacute;c&eacute;dent doit &ecirc;tre utilis&eacute;e.
   </para>
   <example>
    <title>Exemple avec <function>localeconv</function></title>
    <programlisting role="php">
&lt;?php
setlocale(LC_ALL, "en_US");
$locale_info = localeconv();
echo "&lt;PRE&gt;&#92;n";
echo "--------------------------------------------&#92;n";
echo "  Informations mon&eacute;taires pour le serveur local: &#92;n";
echo "--------------------------------------------&#92;n&#92;n";
echo "int_curr_symbol:   {$locale_info["int_curr_symbol"]}&#92;n";
echo "currency_symbol:   {$locale_info["currency_symbol"]}&#92;n";
echo "mon_decimal_point: {$locale_info["mon_decimal_point"]}&#92;n";
echo "mon_thousands_sep: {$locale_info["mon_thousands_sep"]}&#92;n";
echo "positive_sign:     {$locale_info["positive_sign"]}&#92;n";
echo "negative_sign:     {$locale_info["negative_sign"]}&#92;n";
echo "int_frac_digits:   {$locale_info["int_frac_digits"]}&#92;n";
echo "frac_digits:       {$locale_info["frac_digits"]}&#92;n";
echo "p_cs_precedes:     {$locale_info["p_cs_precedes"]}&#92;n";
echo "p_sep_by_space:    {$locale_info["p_sep_by_space"]}&#92;n";
echo "n_cs_precedes:     {$locale_info["n_cs_precedes"]}&#92;n";
echo "n_sep_by_space:    {$locale_info["n_sep_by_space"]}&#92;n";
echo "p_sign_posn:       {$locale_info["p_sign_posn"]}&#92;n";
echo "n_sign_posn:       {$locale_info["n_sign_posn"]}&#92;n";
echo "&lt;/PRE&gt;&#92;n";
?&gt;
    </programlisting>
   </example>
   <para>
    La constante CHAR_MAX est aussi d&eacute;finie ci-dessus.
   </para>
   <note>
    <para>
     Ajout&eacute; en PHP 4.0.5
    </para>
   </note>
   <para>
    Voir aussi
    <function>setlocale</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.ltrim">
  <refnamediv>
   <refname>ltrim</refname>
   <refpurpose>
    Enl&egrave;ve les espaces de d&eacute;but de cha&icirc;ne.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>ltrim</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>ltrim</function> enl&egrave;ve les caract&egrave;res blancs
    plac&eacute;s au d&eacute;but d'une cha&icirc;ne et retourne la
    cha&icirc;ne raccourcie. Les caract&egrave;res blancs sont :
    "&#92;n", "&#92;r", "&#92;t", "&#92;v", "&#92;0", et "&nbsp;".
   </para>
   <para>
    Voir aussi
    <function>chop</function> et
    <function>trim</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.md5">
  <refnamediv>
   <refname>md5</refname>
   <refpurpose>Calcule un md5 avec la cha&icirc;ne.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>md5</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    Crypte la cha&icirc;ne <parameter>str</parameter> en utilisant la
    m&eacute;thode MD5 (voir
    <ulink url="&url.rfc;rfc1321.html">RSA Data Security, Inc. MD5 Message-Digest Algorithm</ulink>.).
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.metaphone">
  <refnamediv>
   <refname>metaphone</refname>
   <refpurpose>Calcule la cl&eacute; m&eacute;taphone d'une cha&icirc;ne de caract&egrave;res.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>metaphone</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>metaphone</function> calcule la cl&eacute; m&eacute;taphone
    de la cha&icirc;ne <parameter>str</parameter>.
   </para>
   <para>
    Similairement &agrave; <function>soundex</function>, m&eacute;taphone
    cr&eacute;e une cl&eacute; similaire pour des sons proches. C'est une
    fonction plus pr&eacute;cise que <function>soundex</function> car elle
    prend en compte les r&egrave;gles basiques de la prononciation en anglais.
    Les cl&eacute;s m&eacute;taphones sont de longueur variable.
   </para>
   <para>
    Le m&eacute;taphone a &eacute;t&eacute; d&eacute;velopp&eacute;e par Lawrence
    Philips &lt;lphilips@verity.com>. Elle est d&eacute;crite dans
    ["Practical Algorithms for Programmers", Binstock &amp; Rex, Addison Wesley, 1995].
    <note>
     <para>
      C<function>metaphone</function> a &eacute;t&eacute; ajout&eacute;e
      en PHP 4.0.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.nl2br">
  <refnamediv>
   <refname>nl2br</refname>
   <refpurpose>Ins&egrave;re une c&eacute;sure HTML avant chaque nouvelle ligne.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>nl2br</methodname>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>nl2br</function> retourne la cha&icirc;ne
    <parameter>string</parameter> dont toutes les lignes ont &eacute;t&eacute;
    rempla&ccedil;&eacute;es par '<literal>&lt;BR /&gt;</literal>'.
   </para>
   <para>
    A partir de la version PHP 4.0.5, <function>nl2br</function> est d&eacute;sormais
    compatible XHTML. Toutes les versions ant&eacute;rieures retourneront
    la cha&icirc;ne <parameter>string</parameter> avec '&lt;br&gt;' rempla&ccedil;ant
    les nouvelles lignes, au lieu de '&lt;br /&gt;'.
   </para>
   <para>
    Voir aussi
    <function>htmlspecialchars</function> et
    <function>htmlentities</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.ord">
  <refnamediv>
   <refname>ord</refname>
   <refpurpose>Retourne la valeur ASCII du caract&egrave;re.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>ord</methodname>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>ord</function> retourne la valeur ASCII du premier
    caract&egrave;re de la cha&icirc;ne
    <parameter>string</parameter>. <function>ord</function> est le contraire de
    <function>chr</function>.
    <example>
     <title>Exemple avec <function>ord</function></title>
     <programlisting role="php">
&lt;?php
if (ord($str) == 10) {
    echo "Le premier caract&egrave;re de &#92;$str est un retour chariot.&#92;n";
}
?&gt;
     </programlisting>
    </example>
   </para>
   <simpara>
    Voir aussi
    <function>chr</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.parse-str">
  <refnamediv>
   <refname>parse_str</refname>
   <refpurpose>
    Analyse une cha&icirc;ne, et en d&eacute;duit des variables et leur valeur.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>parse_str</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
     <methodparam choice="opt"><type>array</type><parameter>arr</parameter></methodparam>
    </methodsynopsis>
   <para>
    Analyse la cha&icirc;ne <parameter>str</parameter> comme si
    c'&eacute;tait une cha&icirc;ne pass&eacute;e par URL, et affecte les
    variables qu'elle y trouve.
   </para>
   <para>
    <example>
     <title>Utilisation de <function>parse_str</function></title>
     <programlisting role="php">
&lt;?php
$str = "first=valeur&amp;second[]=ceci+marche&amp;second[]=encore";
parse_str($str);
echo $first;     /* affiche "valeur" */
echo $second[0]; /* affiche "ceci marche" */
echo $second[1]; /* affiche "encore" */
?&gt;
     </programlisting>
    </example>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.print">
  <refnamediv>
   <refname>print</refname>
   <refpurpose>Affiche une cha&icirc;ne.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <methodname>print</methodname>
     <methodparam><type>string</type><parameter>arg</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>print</function> affiche <parameter>arg</parameter>.
   </simpara>
   <simpara>
    Voir aussi
    <function>echo</function>,
    <function>printf</function> et
    <function>flush</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.printf">
  <refnamediv>
   <refname>printf</refname>
   <refpurpose>Affiche une cha&icirc;ne format&eacute;e.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>printf</methodname>
     <methodparam><type>string</type><parameter>format</parameter></methodparam>
     <methodparam choice="opt"><type>mixed</type><parameter>args</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>printf</function> affiche les arguments en fonction
    du <parameter>format</parameter>. Ce format est d&eacute;crit
    en d&eacute;tails dans la documentation de <function>sprintf</function>.
   </simpara>
   <simpara>
    Voir aussi
    <function>print</function>,
    <function>sprintf</function>,
    <function>sscanf</function>,
    <function>fscanf</function> et
    <function>flush</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.quoted-printable-decode">
  <refnamediv>
   <refname>quoted_printable_decode</refname>
   <refpurpose>
    D&eacute;code une cha&icirc;ne
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>quoted_printable_decode</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>quoted_printable_decode</function> retourne une cha&icirc;ne
    8-bit r&eacute;sultant du d&eacute;codage de la cha&icirc;ne
    <parameter>str</parameter>. <function>quoted_printable_decode</function>
    est similaire &agrave; <function>imap_qprint</function>, hormis le fait
    qu'elle ne requiert pas le module <acronym>IMAP</acronym>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.quotemeta">
  <refnamediv>
   <refname>QuoteMeta</refname>
   <refpurpose>
    Ajoute un antislash devant tous les caract&egrave;res m&eacute;ta
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>quotemeta</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>quotemeta</function> retourne une version de la
    cha&icirc;ne <parameter>str</parameter>, avec un antislash
    (<literal>&#92;</literal>) devant tous les caract&egrave;res de la liste
    ci-dessous : <screen>. &#92; + * ? [ ^ ] ( $ )</screen>.
   </para>
   <simpara>
    Voir aussi
    <function>addslashes</function>,
    <function>htmlentities</function>,
    <function>htmlspecialchars</function>,
    <function>nl2br</function> et
    <function>stripslashes</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.rtrim">
  <refnamediv>
   <refname>rtrim</refname>
   <refpurpose>Efface les espaces de fin de cha&icirc;ne.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>rtrim</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>rtrim</function> la cha&icirc;ne <parameter>str</parameter>,
    d&eacute;barass&eacute;e de ses espaces terminaux, y compris les
    nouvelles lignes. <function>rtrim</function> est un alias de
    <function>chop</function>.
    <example>
     <title>Exemple avec <function>rtrim</function></title>
     <programlisting role="php">
&lt;?php
$trimmed = rtrim($line);
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>trim</function>,
    <function>ltrim</function> et
    <function>rtrim</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.sscanf">
  <refnamediv>
   <refname>sscanf</refname>
   <refpurpose>Analyse une fonction en fonction d'un format</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>sscanf</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
     <methodparam><type>string</type><parameter>format</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>var1</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>sscanf</function> est le compl&eacute;mentaire de
    <function>printf</function>. <function>sscanf</function> lit les
    donn&eacute;es de la cha&icirc;ne <parameter>str</parameter> et
    interpr&egrave;te son contenu en fonction du format
    <parameter>format</parameter>. Si seulement deux param&egrave;tres
    sont pass&eacute;s &agrave; <function>sscanf</function>,
    les valeurs obtenues seront retourn&eacute;es sous forme d'un tableau.
    <example>
     <title>Exemple avec <function>sscanf</function></title>
     <programlisting role="php">
&lt;?php
// lecture d'un num&eacute;ro de s&eacute;rie
$serial = sscanf("SN/2350001","SN/%d");
// et la date de fabrication
$mandate = "January 01 2000";
list($month, $day, $year) = sscanf($mandate,"%s %d %d");
echo "Le produit $serial a &eacute;t&eacute; fabriqu&eacute; le: $year-".substr($month,0,3)."-$day&#92;n";
?&gt;
     </programlisting>
    </example>
    Si les param&egrave;tres optionnels sont pass&eacute;s,
    <function>sscanf</function> retournera le nombre de valeurs
    assign&eacute;es. Les options doivent &ecirc;tre pass&eacute;es
    par r&eacute;f&eacute;rence.
    <example>
     <title>Utilisation des options avec <function>sscanf</function></title>
     <programlisting role="php">
&lt;?php
// Lecture des informations d'auteur, et g&eacute;n&eacute;ration
// d'une entr&eacute;e DocBook
$auth = "24&#92;tVictor Hugo";
$n = sscanf($auth,"%d&#92;t%s %s", &amp;$id, &amp;$first, &amp;$last);
echo "&lt;auteur id='$id'&gt;
    &lt;Pr&eacute;nom&gt;$first&lt;/firstname&gt;
    &lt;Nom&gt;$last&lt;/surname&gt;
&lt;/auteur&gt;&#92;n";
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>fscanf</function>,
    <function>printf</function> et
    <function>sprintf</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.setlocale">
  <refnamediv>
   <refname>setlocale</refname>
   <refpurpose>Change les informations locales.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>setlocale</methodname>
     <methodparam><type>mixed</type><parameter>category</parameter></methodparam>
     <methodparam><type>string</type><parameter>locale</parameter></methodparam>
    </methodsynopsis>
   <para>
    <parameter>category</parameter> est une cha&icirc;ne ou une
    constante qui sp&eacute;cifie la cat&eacute;gorie de fonctions
    qui va &ecirc;tre affect&eacute;e par les informations locales :
    <itemizedlist>
     <listitem>
      <simpara>
       LC_ALL : toutes les fonctions ci-dessous
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       LC_COLLATE : pour les comparaisons de cha&icirc;nes
       (voir <function>strcoll</function>)
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       LC_CTYPE : pour la classification de caract&egrave;res et les conversions,
       par exemple <function>strtoupper</function>
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       LC_MONETARY : pour localeconv() - (en cours d'impl&eacute;mentation)
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       LC_NUMERIC : pour les s&eacute;parateurs d&eacute;cimaux
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       LC_TIME : pour le format des dates et heures date avec
       <function>strftime</function>
      </simpara>
     </listitem>
    </itemizedlist>
   </para>
   <para>
    Si <parameter>locale</parameter> est une cha&icirc;ne vide
    (<literal>""</literal>), les noms locaux prendront la valeur
    des variables d'environnement de m&ecirc;me nom, ou &agrave;
    partir de "LANG".
   </para>
   <para>
    Si <parameter>locale</parameter> vaut z&eacute;ro ou
    <literal>"0"</literal>, la valeur reste inchang&eacute;e,
    mais l'&eacute;tat courant est retourn&eacute;.
   </para>
   <para>
    <function>setlocale</function> retourne la valeur courante, ou
    &false; si la fonctionnalit&eacute; n'est pas encore
    impl&eacute;ment&eacute;e pour la plate-forme. Une cat&eacute;gorie
    invalide provoque une alerte.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.similar-text">
  <refnamediv>
   <refname>similar_text</refname>
   <refpurpose>
    Calcule la similarit&eacute; de deux cha&icirc;nes.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>similar_text</methodname>
     <methodparam><type>string</type><parameter>first</parameter></methodparam>
     <methodparam><type>string</type><parameter>second</parameter></methodparam>
     <methodparam choice="opt"><type>double</type><parameter>percent</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>similar_text</function> calcule la similarit&eacute;
    entre deux cha&icirc;nes,
    comme d&eacute;crit par Oliver [1993]. Notez que cette
    impl&eacute;mentation n'utilise pas une pile, comme dans le
    pseudo-code d'Oliver, mais un appel r&eacute;cursif qui
    acc&eacute;l&egrave;re parfois l'ex&eacute;cution. Notez aussi que
    la complexit&eacute; de cet algorithme est en o(N**3) avec N la taille
    de la plus grande cha&icirc;ne.
   </para>
   <para>
    En passant une r&eacute;f&eacute;rence comme troisi&egrave;me argument,
    <function>similar_text</function> va calculer le pourcentage de
    similarit&eacute;. Il retourne le nombre de caract&egrave;res
    correspondant l'un &agrave; l'autre, d'une cha&icirc;ne &agrave; l'autre.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.soundex">
  <refnamediv>
   <refname>soundex</refname>
   <refpurpose>Calcule la valeur soundex d'une cha&icirc;ne.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>soundex</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>soundex</function> calcule la valeur soundex de
    <parameter>str</parameter>.
   </para>
   <para>
    Une valeur Soundex est telle que deux mots prononc&eacute;s de
    la m&ecirc;me fa&ccedil;on auront des valeurs Soundex identiques.
    Cela permet d'effectuer des recherches dans les bases de donn&eacute;es,
    si vous connaissez la prononciation mais pas l'orthographe.
    <function>soundex</function> retourne une cha&icirc;ne de 4
    caract&egrave;res, commen&ccedil;ant par une lettre.
   </para>
   <para>
    <function>soundex</function> particuli&egrave;re a &eacute;t&eacute;
    d&eacute;crite par Donald Knuth dans "The Art Of Computer Programming,
    vol. 3: Sorting And Searching", Addison-Wesley (1973), pp. 391-392.
   </para>
   <para>
    Attention : le soundex d&eacute;pend de la langue, et le soundex PHP
    est optimis&eacute; pour l'anglais. Des versions fran&ccedil;aises existent
    sous forme de script.
   </para>
   <para>
    <example>
     <title>Exemple avec Soundex</title>
     <programlisting role="php">
&lt;?php
soundex("Euler") == soundex("Ellery") == 'E460';
soundex("Gauss") == soundex("Ghosh") == 'G200';
soundex("Knuth") == soundex("Kant") == 'H416';
soundex("Lloyd") == soundex("Ladd") == 'L300';
soundex("Lukasiewicz") == soundex("Lissajous") == 'L222';
?&gt;
     </programlisting>
    </example>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.sprintf">
  <refnamediv>
   <refname>sprintf</refname>
   <refpurpose>Retourne une cha&icirc;ne format&eacute;e.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>sprintf</methodname>
     <methodparam><type>string</type><parameter>format</parameter></methodparam>
     <methodparam choice="opt"><type>mixed</type><parameter>args</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>sprintf</function> retourne une cha&icirc;ne
    format&eacute;e avec le format <parameter>format</parameter>.
   </simpara>
   <simpara>
    La cha&icirc;ne de format est compos&eacute;e de 0 ou plus directives :
    g&eacute;n&eacute;ralement des caract&egrave;res qui sont recopi&eacute;s
    tels quels (hormis <literal>%</literal>), et des sp&eacute;cifications,
    chacune d'elle disposant de son propre param&egrave;tre. Cela s'applique
    &agrave; <function>sprintf</function> et <function>printf</function>.
   </simpara>
   <para>
    Chaque conversion consiste en un signe pourcentage (<literal>%</literal>),
    suivi d'un ou plusieurs &eacute;l&eacute;ments parmi ceux-ci :
    <orderedlist>
     <listitem>
      <simpara>
       Une option de remplissage, qui indique quel caract&egrave;re sera
       utilis&eacute; pour le remplissage, et la taille finale de la
       cha&icirc;ne. Le caract&egrave;re de remplissage peut &ecirc;tre
       un espace ou le caract&egrave;re z&eacute;ro (<literal>0</literal>).).
       La valeur par d&eacute;faut est l'espace. Une autre valeur peut
       &ecirc;tre sp&eacute;cifi&eacute;e en la pr&eacute;fixant par un
       guillemet simple (<literal>'</literal>). Voir les exemples plus loin.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       Un argument optionnel <emphasis>alignment sp&eacute;cifier</emphasis> qui indique
       que le r&eacute;sultat doit &ecirc;tre justifi&eacute; &agrave; droite ou
       &agrave; gauche. Par d&eacute;faut, il est justifi&eacute; &agrave; gauche.
       Le caract&egrave;re <literal>-</literal> signifie : justification &agrave;
       droite.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       Argument optionnel, <emphasis>width sp&eacute;cifier</emphasis> indique le nombre
       minimum de caract&egrave;res que la conversion devrait retourner.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       Argument optionnel, <emphasis>precision sp&eacute;cifier</emphasis> indique le nombre
       de chiffres utilis&eacute; pour afficher un nombre &agrave; virgule flottante.
       Cette option n'a d'effet que sur les nombres &agrave; virgule de type double
       (Une autre fonction pratique pour formater les nombres est :
       <function>number_format</function>).
      </simpara>
     </listitem>
     <listitem>
      <para>
       <emphasis>type specifier</emphasis> indique le type de donn&eacute;es
       pass&eacute;es en argument. Les types possibles sont :
       <simplelist>
       <member>
       <literal>%</literal> - un signe pourcentage : aucun argument n&eacute;cessaire.
       </member>
       <member>
       <literal>b</literal> - l'argument est trait&eacute; comme un entier, et
       repr&eacute;sent&eacute; comme un nombre binaire.
       </member>
       <member>
       <literal>c</literal> - l'argument est trait&eacute; comme un entier, et
       repr&eacute;sent&eacute; comme un nombre ascii.
       </member>
       <member>
       <literal>d</literal> - l'argument est trait&eacute; comme un entier,
       et repr&eacute;sent&eacute; comme un nombre d&eacute;cimal.
       </member>
       <member>
        <literal>u</literal> - l'argument est trait&eacute; comme un entier,
        et repr&eacute;sent&eacute; comme un nombre d&eacute;cimal non sign&eacute;.
       </member>
       <member>
       <literal>f</literal> - l'argument est trait&eacute; comme un double,
       et repr&eacute;sent&eacute; comme un nombre &agrave; virgule flottante.
       </member>
       <member>
       <literal>o</literal> - l'argument est trait&eacute; comme un entier,
       et repr&eacute;sent&eacute; comme un nombre octal.
       </member>
       <member>
       <literal>s</literal> - l'argument est trait&eacute; tel quel, et
       repr&eacute;sent&eacute; comme une cha&icirc;ne.
       </member>
       <member>
       <literal>x</literal> - l'argument est trait&eacute; comme un entier,
       et repr&eacute;sent&eacute; comme un nombre hexad&eacute;cimal (en minuscules).
       </member>
       <member>
       <literal>X</literal> - l'argument est trait&eacute; comme un entier,
       et repr&eacute;sent&eacute; comme un nombre hexad&eacute;cimal (en majuscules).
       </member>
       </simplelist>
      </para>
     </listitem>
    </orderedlist>
   </para>
   <para>
    A partir de PHP 4.0.6, le param&egrave;tre <parameter>format</parameter>
    supportera aussi la num&eacute;rotation des arguments, et leur &eacute;change.
    Par exemple :
    <example>
     <title>Echange d'arguments : cas habituel</title>
     <programlisting role="php">
&lt;?php
$format = "Il y a %d singes dans le %s";
printf($format,$num,$location);
?&gt;
     </programlisting>
    </example>
    Cela pourra afficher "Il y a 5 singes dans le baobab". Mais imaginons
    un instant que nous cr&eacute;ons cette cha&icirc;ne &agrave; partir
    d'un fichier s&eacute;par&eacute;, car nous voulons internationaliser
    le message. On voudra notamment &eacute;crire librement :
    <example>
     <title>Echange d'arguments : cas probl&eacute;matique</title>
     <programlisting role="php">
&lt;?php
$format = "Le %s contient %d singes";
printf($format,$num,$location);
?&gt;
     </programlisting>
    </example>
    Maintenant, on a un probl&egrave;me. L'ordre d'utilisation des variables
    dans la cha&icirc;ne de formatage n'est pas celui d'appel de la
    fonction <function>sprintf</function>. L'id&eacute;al serait de pouvoir
    garder l'ordre des arguments, quel que soit l'ordre des variables
    fournies. Il faudrait donc indiquer dans la cha&icirc;ne de formatage
    dans quel ordre utiliser les valeurs. On pourrait &eacute;crire ceci
    &agrave; la place:
    <example>
     <title>Echange d'arguments : solution</title>
     <programlisting role="php">
&lt;?php
$format = "Le %2&#92;$s contient %1&#92;$d singes";
printf($format,$num,$location);
?&gt;
     </programlisting>
    </example>
    Et vous pouvez d&eacute;sormais r&eacute;p&eacute;ter les variables sans ajouter
    de nouvel argument. Par exemple :
    <example>
     <title>Echange d'arguments : r&eacute;p&eacute;tition</title>
     <programlisting role="php">
&lt;?php
$format = "Le %2&#92;$s contient %1&#92;$d singes.  C'est un beau %2&#92;$s, avec %1&#92;$d signes dessus.";
printf($format,$num,$location);
?&gt;
     </programlisting>
    </example>
   </para>
   <simpara>
    Voir aussi
    <function>printf</function>,
    <function>sscanf</function>,
    <function>fscanf</function> et
    <function>number_format</function>.
   </simpara>
   <para>
    <example>
     <title>
      Exemple avec <function>sprintf</function>: compl&eacute;t&eacute;
      avec des z&eacute;ros
     </title>
     <programlisting role="php">
&lt;?php
$isodate = sprintf("%04d-%02d-%02d", $year, $month, $day);
?&gt;
     </programlisting>
    </example>
    <example>
     <title>Exemple avec <function>sprintf</function>: format mon&eacute;taire</title>
     <programlisting role="php">
&lt;?php
$money1 = 68.75;
$money2 = 54.35;
$money = $money1 + $money2;
// echo $money affichera "123.1";
$formatted = sprintf("%01.2f", $money);
// echo $formatted affichera "123.10"
?&gt;
     </programlisting>
    </example>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strncasecmp">
  <refnamediv>
   <refname>strncasecmp</refname>
   <refpurpose>
    Compare en binaire des cha&icirc;nes de caract&egrave;res
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strncasecmp</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
     <methodparam><type>int</type><parameter>len</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strncasecmp</function> est similaire &agrave; <function>strcasecmp</function>,
    &agrave; la diff&eacute;rence pr&egrave;s qu'elle permet de limiter le nombre de
    caract&egrave;res utilis&eacute;s pour comparer  <parameter>str1</parameter> et
    <parameter>str1</parameter>, avec le param&egrave;tre <parameter>len</parameter>.
    Si une des cha&icirc;nes est plus courte que <parameter>len</parameter>,
    alors la longueur de cette cha&icirc;ne sera utilis&eacute;e pour effectuer
    la comparaison.
   </para>
   <simpara>
    <function>strncasecmp</function> retourne &lt; 0 si <parameter>str1</parameter> est
    plus petit que <parameter>str2</parameter>; &gt; 0 si <parameter>str1</parameter>
    est plus grand que <parameter>str2</parameter>, et 0 si elles sont
    &eacute;gales.
   </simpara>
   <simpara>
    Voir aussi
    <function>ereg</function>,
    <function>strcasecmp</function>,
    <function>strcmp</function>,
    <function>substr</function>,
    <function>stristr</function> et
    <function>strstr</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.strcasecmp">
  <refnamediv>
   <refname>strcasecmp</refname>
   <refpurpose>
    Compare en binaire des cha&icirc;nes, insensible &agrave; la casse.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strcasecmp</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strcasecmp</function> retourne &lt; 0 si
    <parameter>str1</parameter> est plus petit que
    <parameter>str2</parameter>; &gt; 0 si <parameter>str1</parameter>
    est plus grand que <parameter>str2</parameter>, et 0 s'ils sont &eacute;gaux.
    <example>
     <title>Exemple avec <function>strcasecmp</function></title>
     <programlisting role="php">
&lt;?php
$var1 = "Bonjour";
$var2 = "bonjour";
if ( !strcasecmp($var1,$var2) ) {
    echo '$var1 est &eacute;gal &agrave; $var2, &agrave; la casse pr&egrave;s.';
}
?&gt;
     </programlisting>
    </example>
   </para>
   <simpara>
    Voir aussi
    <function>ereg</function>,
    <function>strcmp</function>,
    <function>substr</function>,
    <function>stristr</function>,
    <function>strncasecmp</function> et
    <function>strstr</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.strchr">
  <refnamediv>
   <refname>strchr</refname>
   <refpurpose>
    Renvoie la cha&icirc;ne &agrave; partir de la premi&egrave;re occurrence
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>strchr</methodname>
     <methodparam><type>string</type><parameter>haystack</parameter></methodparam>
     <methodparam><type>string</type><parameter>needle</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strchr</function> est un alias de <function>strstr</function>,
    et lui est identique en tous points.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strcmp">
  <refnamediv>
   <refname>strcmp</refname>
   <refpurpose>Compare en binaire des cha&icirc;nes.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strcmp</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>strcmp</function> retourne &lt; 0 si <parameter>str1</parameter>
    est plus petit que <parameter>str2</parameter>; &gt; 0 si
    <parameter>str1</parameter> est plus grand que
    <parameter>str2</parameter>, et 0 s'ils sont &eacute;gaux.
   </simpara>
   <simpara>
    Notez bien que la comparaison est sensible &agrave; la casse.
   </simpara>
   <simpara>
    Voir aussi
    <function>ereg</function>,
    <function>strcasecmp</function>,
    <function>substr</function>,
    <function>stristr</function>,
    <function>strncmp</function>,
    <function>strncasecmp</function> et
    <function>strstr</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.strcoll">
  <refnamediv>
   <refname>strcoll</refname>
   <refpurpose>Compare des cha&icirc;nes localis&eacute;es</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strcoll</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>strcoll</function> retourne &lt; 0 si <parameter>str1</parameter>
    est plus petit que <parameter>str2</parameter>; &gt; 0 si
    <parameter>str1</parameter> est plus grand que <parameter>str2</parameter>,
    et 0 si elles sont &eacute;gales. <function>strcoll</function> utilise la
    configuration locale pour effectuer les comparaisons. Si la
    configuration locale est : C ou POSIX, <function>strcoll</function>
    est &eacute;quivalente &agrave; <function>strcmp</function>.
   </simpara>
   <simpara>
    Notez que cette comparaison est sensible &agrave; la casse, et que contrairement
    &agrave; <function>strcmp</function>, <function>strcoll</function> n'est pas
    binaire.
   </simpara>
   <note>
    <simpara>
     Ajout&eacute;e en PHP 4.0.5.
    </simpara>
   </note>
   <simpara>
    Voir aussi
    <function>ereg</function>,
    <function>strcmp</function>,
    <function>strcasecmp</function>,
    <function>substr</function>,
    <function>stristr</function>,
    <function>strncasecmp</function>,
    <function>strncmp</function>,
    <function>strstr</function> et
    <function>setlocale</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.strcspn">
  <refnamediv>
   <refname>strcspn</refname>
   <refpurpose>
    Recherche la longueur du premier segment de cha&icirc;ne qui ne corresponde pas
    au masque donn&eacute;.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strcspn</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>strcspn</function> retourne la longueur du premier segment
    de la cha&icirc;ne <parameter>str1</parameter> qui
    <emphasis>ne</emphasis> contiennent <emphasis>aucun</emphasis> des
    caract&egrave;res de la cha&icirc;ne <parameter>str2</parameter>.
   </simpara>
   <simpara>
    Voir aussi
    <function>strspn</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.strip-tags">
  <refnamediv>
   <refname>strip_tags</refname>
   <refpurpose>Enl&egrave;ve les balises HTML et PHP.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>strip_tags</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>allowable_tags</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strip_tags</function> recherche et supprime toutes les balises
    HTML et PHP d'une cha&icirc;ne. En cas de balises non ferm&eacute;es, ou
    de balises mal form&eacute;es, elle g&eacute;n&egrave;re une erreur.
    <function>strip_tags</function> utilise le m&ecirc;me syst&egrave;me que
    la fonction <function>fgetss</function>.
   </para>
   <para>
    Vous pouvez utiliser l'option
    <parameter>allowable_tags</parameter>
    pour sp&eacute;ficier les balises qui seront ignor&eacute;es.
    <note>
     <para>
      <parameter>allowable_tags</parameter> a &eacute;t&eacute;
      ajout&eacute; en PHP 3.0.13, et PHP 4.0B3.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.stripcslashes">
  <refnamediv>
   <refname>StripCSlashes</refname>
   <refpurpose>
    D&eacute;quote une cha&icirc;ne quot&eacute;e avec addcslashes()
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>stripcslashes</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>stripcslashes</function> retourne une cha&icirc;ne dont les
    anti-slash ont &eacute;t&eacute; supprim&eacute;s. <function>stripcslashes</function>
    reconna&icirc;t les <literal>&#92;n</literal>, <literal>&#92;r</literal>...,
    et les repr&eacute;sentations octales et hexad&eacute;cimales
    utilis&eacute;es en C.
    <note>
     <simpara>
      <function>stripcslashes</function> a &eacute;t&eacute; ajout&eacute; en
      PHP 4.0b3-dev.
     </simpara>
    </note>
   </para>
   <simpara>
    Voir aussi
    <function>addcslashes</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.stripslashes">
  <refnamediv>
   <refname>StripSlashes</refname>
   <refpurpose>Enl&egrave;ve les slashs ajout&eacute;s par la fonction addslashes()</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>stripslashes</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>stripslashes</function> retourne une cha&icirc;ne dont
    tous les slashs ont &eacute;t&eacute; supprim&eacute;s.
    (<literal>&#92;'</literal> devient <literal>'</literal>) et ainsi de suite).
    Les doubles antislash sont remplac&eacute;s par des simples antislash.
   </para>
   <simpara>
    Voir aussi
    <function>addslashes</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.stristr">
  <refnamediv>
   <refname>stristr</refname>
   <refpurpose>
    strstr(), insensible &agrave; la casse.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>stristr</methodname>
     <methodparam><type>string</type><parameter>haystack</parameter></methodparam>
     <methodparam><type>string</type><parameter>needle</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>stristr</function> retourne tous les &eacute;l&eacute;ments de
    <parameter>haystack</parameter> &agrave; partir de la premi&egrave;re
    occurrence de <parameter>needle</parameter>, jusqu'&agrave; la fin.
    <parameter>needle</parameter> et <parameter>haystack</parameter>
    sont examin&eacute;s sans tenir compte de la casse.
   </para>
   <para>
    Si <parameter>needle</parameter> n'est pas trouv&eacute;, retourne
    &false;.
   </para>
   <para>
    Si <parameter>needle</parameter> n'est pas une cha&icirc;ne, elle est
    convertie en entier, puis est utilis&eacute;e comme si elle &eacute;tait
    pass&eacute;e &agrave; <function>chr</function>.
   </para>
   <para>
    Voir aussi
    <function>strchr</function>,
    <function>strrchr</function>,
    <function>substr</function> et
    <function>ereg</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strlen">
  <refnamediv>
   <refname>strlen</refname>
   <refpurpose>Retourne la longueur de la cha&icirc;ne.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strlen</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strlen</function> retourne la longueur de la cha&icirc;ne
    <parameter>string</parameter>, c'est-&agrave;-dire le nombre de caract&egrave;res.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strnatcmp">
  <refnamediv>
   <refname>strnatcmp</refname>
   <refpurpose>
    Compare des cha&icirc;nes par ordre "naturel"
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strnatcmp</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strnatcmp</function> impl&eacute;mente un algorithme de
    comparaison qui traite les cha&icirc;nes alpha-num&eacute;riques comme
    un &ecirc;tre humain : c'est ce qui est appel&eacute; l'"ordre naturel".
    Un exemple de la diff&eacute;rence de traitement entre
    un tel algorithme et un algorithme de comparaison de cha&icirc;nes
    (comme lorsqu'on utilise <function>strcmp</function>) est
    illustr&eacute; ci-dessous :
    <informalexample>
     <programlisting role="php">
&lt;?php
$arr1 = $arr2 = array("img12.png","img10.png","img2.png","img1.png");
echo "Comparaison standard de cha&icirc;nes&#92;n";
usort($arr1,"strcmp");
print_r($arr1);
echo "&#92;nComparaison de cha&icirc;nes par ordre naturel&#92;n";
usort($arr2,"strnatcmp");
print_r($arr2);
?&gt;
     </programlisting>
    </informalexample>
    L'exemple pr&eacute;c&eacute;dent affiche ceci :
    <informalexample>
     <literallayout>
       <computeroutput>
Comparaison standard de cha&icirc;nes
Array
(
    [0] =&gt; img1.png
    [1] =&gt; img10.png
    [2] =&gt; img12.png
    [3] =&gt; img2.png
)
Comparaison de cha&icirc;nes par ordre naturel
Array
(
    [0] =&gt; img1.png
    [1] =&gt; img2.png
    [2] =&gt; img10.png
    [3] =&gt; img12.png
)
       </computeroutput>
     </literallayout>
    </informalexample>
    Pour plus d'informations, reportez-vous &agrave; Martin Pool <ulink
    url="&url.strnatcmp;">Natural Order String Comparison</ulink>.
   </para>
   <simpara>
    Comme les autres fonctions de comparaison de cha&icirc;nes, elle retourne
    une valeur &lt; 0  si <parameter>str1</parameter> est plus petite que
    <parameter>str2</parameter>; &gt; 0 si <parameter>str1</parameter>
    est plus grande que <parameter>str2</parameter>, et 0 si elles sont &eacute;gales.
   </simpara>
   <simpara>
    Notez que ces comparaisons sont sensibles &agrave; la casse.
   </simpara>
   <simpara>
    Voir aussi
    <function>ereg</function>,
    <function>strcasecmp</function>,
    <function>substr</function>,
    <function>stristr</function>,
    <function>strcmp</function>,
    <function>strncmp</function>,
    <function>strnatcasecmp</function>,
    <function>strstr</function>,
    <function>natsort</function>,
    <function>strncasecmp</function> et
    <function>natcasesort</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.strnatcasecmp">
  <refnamediv>
   <refname>strnatcasecmp</refname>
   <refpurpose>
    Compare des cha&icirc;nes par ordre "naturel" insensible &agrave; la casse
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strnatcasecmp</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strnatcasecmp</function> impl&eacute;mente un algorithme de
    comparaison qui traite les cha&icirc;nes alpha-num&eacute;riques comme un
    &ecirc;tre humain : c'est ce qui est appel&eacute; l'"ordre naturel". Pour
    plus d'informations, reportez-vous &agrave; Martin Pool <ulink
    url="&url.strnatcmp;">Natural Order String Comparison</ulink>.
   </para>
   <simpara>
    Comme les autres fonctions de comparaisons de cha&icirc;nes, elle retourne
    une valeur &lt; 0  si <parameter>str1</parameter> est plus petite que
    <parameter>str2</parameter>; &gt; 0 si <parameter>str1</parameter>
    est plus grande que <parameter>str2</parameter>, et 0 si elles sont &eacute;gales.
   </simpara>
   <simpara>
    Voir aussi
    <function>ereg</function>,
    <function>strcasecmp</function>,
    <function>substr</function>,
    <function>stristr</function>,
    <function>strcmp</function>,
    <function>strncmp</function>,
    <function>strnatcmp</function>,
    <function>strncasecmp</function> et
    <function>strstr</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.strncmp">
  <refnamediv>
   <refname>strncmp</refname>
   <refpurpose>
    Compare en binaire les premiers caract&egrave;res
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strncmp</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
     <methodparam><type>int</type><parameter>len</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strncmp</function> est similaire &agrave; <function>strcmp</function>,
    &agrave; la diff&eacute;rence pr&egrave;s que vous pouvez sp&eacute;cifier
    le nombre limite de caract&egrave;res (<parameter>len</parameter>)
    utilis&eacute;s pour faire la comparaison. Si l'une des cha&icirc;nes
    est plus courte que <parameter>len</parameter>, alors cette longueur
    sera utilis&eacute;e pour faire la comparaison.
   </para>
   <simpara>
    Comme les autres fonctions de comparaisons de cha&icirc;nes, elle retourne
    une valeur &lt; 0  si <parameter>str1</parameter> est plus petite que
    <parameter>str2</parameter>; &gt; 0 si <parameter>str1</parameter>
    est plus grande que <parameter>str2</parameter>, et 0 si elles sont &eacute;gales.
   </simpara>
   <simpara>
    Notez que la comparaison est sensible &agrave; la casse.
   </simpara>
   <simpara>
    Voir aussi
    <function>ereg</function>,
    <function>strcasecmp</function>,
    <function>substr</function>,
    <function>stristr</function>,
    <function>strcmp</function>,
    <function>strncasecmp</function> et
    <function>strstr</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.str-pad">
  <refnamediv>
   <refname>str_pad</refname>
   <refpurpose>Compl&egrave;te une cha&icirc;ne avec une autre</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>str_pad</methodname>
     <methodparam><type>string</type><parameter>input</parameter></methodparam>
     <methodparam><type>int</type><parameter>pad_length</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>pad_string</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>pad_type</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>str_pad</function> compl&egrave;te la cha&icirc;ne
    <parameter>input</parameter> &agrave; droite, &agrave; gauche ou dans les
    deux directions, avec <parameter>pad_string</parameter> jusqu'&agrave; la
    taille de <parameter>pad_length</parameter>. Si <parameter>pad_string</parameter>
    n'est pas fourni, <parameter>input</parameter> est compl&eacute;t&eacute; avec
    des espaces. Sinon, il est compl&eacute;t&eacute; avec
    <parameter>pad_string</parameter>.
   </para>
   <para>
    <parameter>pad_type</parameter> peut prendre les valeurs de
    STR_PAD_RIGHT, STR_PAD_LEFT, ou STR_PAD_BOTH.  Si <parameter>pad_type</parameter>
    n'est pas sp&eacute;cifi&eacute;e, cela vaut STR_PAD_RIGHT.
   </para>
   <para>
    Si <parameter>pad_length</parameter> est n&eacute;gative ou
    inf&eacute;rieure &agrave; la taille courante de la cha&icirc;ne
    <parameter>input</parameter>, aucun compl&eacute;ment n'est ajout&eacute;.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>str_pad</function></title>
     <programlisting role="php">
&lt;?php
$input = "Paris";
print str_pad($input, 10);                      // produces "Paris     "
print str_pad($input, 10, "-=", STR_PAD_LEFT);  // produces "-=-=-Paris"
print str_pad($input, 10, "_", STR_PAD_BOTH);   // produces "__Paris___"
?&gt;
     </programlisting>
    </example>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strpos">
  <refnamediv>
   <refname>strpos</refname>
   <refpurpose>
    Recherche la premi&egrave;re occurrence d'un caract&egrave;re dans une
    cha&icirc;ne.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strpos</methodname>
     <methodparam><type>string</type><parameter>haystack</parameter></methodparam>
     <methodparam><type>string</type><parameter>needle</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>offset</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strpos</function> retourne la position num&eacute;rique de
    la premi&egrave;re occurrence de <parameter>needle</parameter> dans la
    cha&icirc;ne <parameter>haystack</parameter>. Contrairement &agrave;
    <function>strrpos</function>, <parameter>needle</parameter> peut
    &ecirc;tre une cha&icirc;ne.
   </para>
   <para>
    Si <parameter>needle</parameter> n'est pas trouv&eacute;e, retourne
    &false;.
    <note>
     <para>
      Il est facile de confondre la valeur de retour "caract&egrave;re trouv&eacute;
      &agrave; la position 0" et "caract&egrave;re introuvable". Voici comment faire
      la diff&eacute;rence :
      <informalexample>
       <programlisting role="php">
&lt;?php
  // PHP 4.0b3 et plus r&eacute;cent :
  $pos = strpos($machaine, "b");
  if ($pos === FALSE) { // note: trois signes &eacute;gal
    // non trouv&eacute;
  }
  // versions plus anciennes que 4.0b3:
  $pos = strpos("b", $machaine);
  if (is_string($pos) &amp;&amp; !$pos) {
    // non trouv&eacute;
  }
?&gt;
       </programlisting>
      </informalexample>
     </para>
    </note>
   </para>
   <para>
    Si <parameter>needle</parameter> n'est pas une cha&icirc;ne, elle est convertie
    en entier, et utilis&eacute;e comme la valeur ASCII d'un caract&egrave;re.
   </para>
   <para>
    L'argument optionnel <parameter>offset</parameter> permet de pr&eacute;ciser
    le caract&egrave;re &agrave; partir duquel chercher, dans
    <parameter>haystack</parameter>. La position doit &ecirc;tre relative au
    d&eacute;but de la cha&icirc;ne <parameter>haystack</parameter>.
   </para>
   <para>
    Voir aussi
    <function>strrpos</function>,
    <function>strrchr</function>,
    <function>strchr</function>,
    <function>substr</function>,
    <function>stristr</function> et
    <function>strstr</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strrchr">
  <refnamediv>
   <refname>strrchr</refname>
   <refpurpose>
    Recherche la partie terminale d'une cha&icirc;ne apr&egrave;s
    un caract&egrave;re donn&eacute;
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>strrchr</methodname>
     <methodparam><type>string</type><parameter>haystack</parameter></methodparam>
     <methodparam><type>string</type><parameter>needle</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strrchr</function> retourne la partie de la cha&icirc;ne
    <parameter>haystack</parameter> qui commence &agrave; la derni&egrave;re
    occurrence de <parameter>needle</parameter> et va jusqu'&agrave; la fin de
    la cha&icirc;ne <parameter>haystack</parameter>.
   </para>
   <para>
    <function>strrchr</function> retourne &false;
    si <parameter>needle</parameter> n'est pas trouv&eacute;.
   </para>
   <para>
    Si <parameter>needle</parameter> contient plus d'un caract&egrave;re,
    les autres sont ignor&eacute;s.
   </para>
   <para>
    Si <parameter>needle</parameter> n'est pas une cha&icirc;ne, il est converti en
    un entier, et utilis&eacute; comme valeur ordinale.
    <example>
     <title>Exemple avec <function>strrchr</function></title>
     <programlisting role="php">
&lt;?php
// lit le dernier r&eacute;pertoire de $PATH
$dir = substr(strrchr($PATH, ":"), 1);
// lit tout apr&egrave;s la derni&egrave;re ligne
$text = "Line 1&#92;nLine 2&#92;nLine 3";
$last = substr(strrchr($text, 10), 1 );
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>substr</function>,
    <function>stristr</function> et
    <function>strstr</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.str-repeat">
  <refnamediv>
   <refname>str_repeat</refname>
   <refpurpose>R&eacute;p&egrave;te une cha&icirc;ne.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>str_repeat</methodname>
     <methodparam><type>string</type><parameter>input</parameter></methodparam>
     <methodparam><type>int</type><parameter>multiplier</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>str_repeat</function> retourne <parameter>input_str</parameter>
    r&eacute;p&eacute;t&eacute;e <parameter>multiplier</parameter>
    fois. <parameter>multiplier</parameter> doit &ecirc;tre
    sup&eacute;rieur &agrave; 0.
   </para>
   <example>
    <title>Exemple avec <function>str_repeat</function></title>
    <programlisting role="php">
&lt;?php
echo str_repeat("-=", 10);
?&gt;
    </programlisting>
   </example>
   <para>
    Cet exemple affichera "<literal>-=-=-=-=-=-=-=-=-=-=</literal>".
   </para>
   <note>
    <para>
     <function>str_repeat</function> a &eacute;t&eacute; ajout&eacute;e
     en PHP 4.0.
    </para>
   </note>
  </refsect1>
 </refentry>
 <refentry id="function.strrev">
  <refnamediv>
   <refname>strrev</refname>
   <refpurpose>
    Inverse l'ordre des caract&egrave;res d'une cha&icirc;ne.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>strrev</methodname>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strrev</function> retourne <parameter>string</parameter>,
    apr&egrave;s avoir chang&eacute; l'ordre des caract&egrave;res.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strrpos">
  <refnamediv>
   <refname>strrpos</refname>
   <refpurpose>
    Recherche la derni&egrave;re occurrence d'un caract&egrave;re dans une
    cha&icirc;ne.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strrpos</methodname>
     <methodparam><type>string</type><parameter>haystack</parameter></methodparam>
     <methodparam><type>char</type><parameter>needle</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strrpos</function> retourne la position num&eacute;rique de la
    derni&egrave;re occurrence de <parameter>needle</parameter> dans la
    cha&icirc;ne <parameter>haystack</parameter>. <function>strrpos</function>
    ne peut accepter qu'un seul caract&egrave;re.
   </para>
   <para>
    Si <parameter>needle</parameter> n'est pas trouv&eacute;, retourne &false;.
   </para>
   <note>
    <para>
     Il est facile de confondre la valeur de retour "caract&egrave;re trouv&eacute;
     &agrave; la position 0" et "caract&egrave;re introuvable". Voici comment faire
     la diff&eacute;rence :
     <informalexample>
      <programlisting role="php">
&lt;?php
// PHP 4.0b3 et plus r&eacute;cent :
$pos = strpos("b", $mystring);
if ($pos === <literal>FALSE</literal>) { // note: trois &eacute;gal signes
    // non trouv&eacute;
}
// versions plus anciennes que 4.0b3:
$pos = strpos("b", $mystring);
if (is_string($pos) &amp;&amp; !$pos) {
    // non trouv&eacute;
}
?&gt;
      </programlisting>
     </informalexample>
    </para>
   </note>
   <para>
    Si <parameter>needle</parameter> n'est pas une cha&icirc;ne, elle est
    convertie en entier, et utilis&eacute;e comme la valeur ASCII d'un
    caract&egrave;re.
   </para>
   <para>
    Voir aussi
    <function>strpos</function>,
    <function>strrchr</function>,
    <function>substr</function>,
    <function>stristr</function> et
    <function>strstr</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strspn">
  <refnamediv>
   <refname>strspn</refname>
   <refpurpose>
    Retourne la longueur du premier segment qui v&eacute;rifie le masque.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>strspn</methodname>
     <methodparam><type>string</type><parameter>str1</parameter></methodparam>
     <methodparam><type>string</type><parameter>str2</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>strspn</function> retourne la longueur du premier segment de
    <parameter>str1</parameter> qui est constitu&eacute; enti&egrave;rement
    de caract&egrave;res dans la cha&icirc;ne <parameter>str2</parameter>.
   </simpara>
   <para>
    <informalexample>
     <programlisting role="php">
&lt;?php
strspn("42 est une r&eacute;ponse, quelle est la question...", "1234567890");
?&gt;
     </programlisting>
     <para>
      Cet exemple affichera "2", car "42" est la plus longue cha&icirc;ne contenant
      des chiffres dans la cha&icirc;ne de questions.
     </para>
    </informalexample>
   </para>
   <simpara>
    Voir aussi
    <function>strcspn</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.strstr">
  <refnamediv>
   <refname>strstr</refname>
   <refpurpose>
    Renvoie la cha&icirc;ne &agrave; partir de la premi&egrave;re occurrence
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>strstr</methodname>
     <methodparam><type>string</type><parameter>haystack</parameter></methodparam>
     <methodparam><type>string</type><parameter>needle</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strstr</function> retourne toute la cha&icirc;ne
    <parameter>haystack</parameter> &agrave; partir de la premi&egrave;re
    occurrence de <parameter>needle</parameter>, jusqu'&agrave; la fin.
   </para>
   <para>
    Si <parameter>needle</parameter> n'est pas trouv&eacute;, retourne
    &false;.
   </para>
   <para>
    <note>
     <para>
      <function>strstr</function> est sensible &agrave;
      la casse. Si besoin est, utilisez <function>stristr</function>.
     </para>
    </note>
   </para>
   <para>
    Si <parameter>needle</parameter> n'est pas une cha&icirc;ne, elle est
    convertie en entier, et utilis&eacute;e comme valeur ordinale d'un
    caract&egrave;re.
    <example>
     <title>Exemple avec <function>strstr</function></title>
     <programlisting role="php">
&lt;?php
$email = 'sterling@designmultimedia.com';
$domain = strstr($email, '&#64;');
print $domain;
// affiche "&#64;designmultimedia.com"
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>stristr</function>,
    <function>strrchr</function>,
    <function>substr</function> et
    <function>ereg</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strtok">
  <refnamediv>
   <refname>strtok</refname>
   <refpurpose>Morcelle une cha&icirc;ne</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>strtok</methodname>
     <methodparam><type>string</type><parameter>arg1</parameter></methodparam>
     <methodparam><type>string</type><parameter>arg2</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strtok</function> est utilis&eacute;e pour morceler une
    cha&icirc;ne. Pour cela, si vous avez une cha&icirc;ne du type "ceci
    est une cha&icirc;ne exemple", vous pouvez la morceler en mots, en
    utilisant ' ' comme d&eacute;limiteur.
    <example>
     <title>Exemple avec <function>strtok</function></title>
     <programlisting role="php">
&lt;?php
$string = "ceci est une cha&icirc;ne exemple";
$tok = strtok($string," ");
while ($tok) {
    echo "Mot=$tok&lt;br&gt;";
    $tok = strtok(" ");
}
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Notez que seul, le premier appel &agrave; <function>strtok</function> utilise
    l'argument cha&icirc;ne. Apr&egrave;s, chaque appel &agrave; strtok ne requiert
    que le d&eacute;limiteur &agrave; utiliser. Pour recommencer, vous pouvez
    simplement appeler <function>strtok</function> avec un nouvel argument,
    pour l'initialiser. Notez que vous pouvez mettre des d&eacute;limiteurs
    multiples. La cha&icirc;ne sera morcel&eacute;e &agrave; chaque fois
    qu'on rencontrera un des d&eacute;limiteurs.
   </para>
   <para>
    Soyez prudents avec les d&eacute;limiteurs qui sont &eacute;gaux &agrave; "0".
    Cette valeur sera confondue avec &false;.
   </para>
   <para>
    Voir aussi
    <function>split</function> et
    <function>explode</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strtolower">
  <refnamediv>
   <refname>strtolower</refname>
   <refpurpose>Met tous les caract&egrave;res en minuscules.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>strtolower</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strtolower</function> retourne <parameter>string</parameter>
    avec tous les caract&egrave;res alphab&eacute;tiques en minuscule.
   </para>
   <para>
    Notez que le caract&egrave;re 'alphab&eacute;tique' est d&eacute;termin&eacute;
    par la table de caract&egrave;res locale. Par exemple, dans la table des
    caract&egrave;res par d&eacute;faut du "C", des caract&egrave;res tels que
    a-umlaut (&auml;) ne seront pas convertis.
   </para>
   <example>
    <title>Exemple avec <function>strtolower</function></title>
    <programlisting role="php">
&lt;?php
$str = "Marie A Un Petit Agneau, Et Elle L'Adore";
$str = strtolower($str);
print $str;
# Affiche : marie a un petit agneau, et elle l'adore
?&gt;
    </programlisting>
   </example>
   <para>
    Voir aussi
    <function>strtoupper</function> et
    <function>ucfirst</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strtoupper">
  <refnamediv>
   <refname>strtoupper</refname>
   <refpurpose>Met tous les caract&egrave;res en majuscules.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>strtoupper</methodname>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strtoupper</function> retourne <parameter>string</parameter> avec
    tous ses caract&egrave;res alphab&eacute;tiques mis en majuscule.
   </para>
   <para>
    Notez que le caract&egrave;re 'alphab&eacute;tique' est d&eacute;termin&eacute;
    par la table de caract&egrave;res locale. Par exemple, dans la table des
    caract&egrave;res par d&eacute;faut du "C", des caract&egrave;res tels que
    a-umlaut (&auml;) ne seront pas convertis.
   </para>
   <example>
    <title>Exemple avec <function>strtoupper</function></title>
    <programlisting role="php">
&lt;?php
$str = "Marie A Un Petit Agneau, Et Elle L'Adore";
$str = strtoupper($str);
print $str; # Affiche : MARIE A UN PETIT AGNEAU, ET ELLE L'ADORE
?&gt;
    </programlisting>
   </example>
   <para>
    Voir aussi
    <function>strtolower</function> et
    <function>ucfirst</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.str-replace">
  <refnamediv>
   <refname>str_replace</refname>
   <refpurpose>
    Remplace toutes les occurrences d'une cha&icirc;ne par une autre.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>str_replace</methodname>
     <methodparam><type>mixed</type><parameter>search</parameter></methodparam>
     <methodparam><type>mixed</type><parameter>replace</parameter></methodparam>
     <methodparam><type>mixed</type><parameter>subject</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>str_replace</function> remplace toutes les occurrences de
    <parameter>search</parameter> dans <parameter>subject</parameter> par
    la cha&icirc;ne <parameter>replace</parameter>. Si vous n'avez pas besoin de
    r&egrave;gles de remplacement sophistiqu&eacute;es, utilisez <function>str_replace</function>
    de pr&eacute;f&eacute;rence &agrave; <function>ereg_replace</function> et
    <function>preg_replace</function>.
   </para>
   <para>
    En PHP 4.0.5 et plus r&eacute;cent, chaque param&egrave;tre de
    <function>str_replace</function> peut &ecirc;tre un tableau.
   </para>
   <para>
    Si <parameter>subject</parameter> est un tableau, alors le remplacement
    est effectu&eacute; pour chaque valeur de <parameter>subject</parameter>, et la
    valeur retourn&eacute;e sera un tableau.
   </para>
   <para>
    Si <parameter>search</parameter> et <parameter>replace</parameter> sont
    des tableaux, alors <function>str_replace</function> prend une valeur dans
    chaque tableau, et s'en sert pour chercher et remplacer dans
    <parameter>subject</parameter>.  Si <parameter>replace</parameter> contient
    moins de valeurs que <parameter>search</parameter>, des cha&icirc;nes vides seront
    utilis&eacute;es pour compl&eacute;ter le tableau <parameter>replace</parameter>.
    Si <parameter>search</parameter> est un tableau et <parameter>replace</parameter>
    est une cha&icirc;ne, alors la m&ecirc;me cha&icirc;ne de remplacement
    sera utilis&eacute;e pour chaque valeur de <parameter>search</parameter>.
    Le contraire n'aurait pas beaucoup de sens.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>str_replace</function></title>
     <programlisting role="php">
&lt;?php
$bodytag = str_replace("%body%", "black", "&lt;body text=%body%>");
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    <function>str_replace</function> n'alt&egrave;re pas les donn&eacute;es binaires.
   </para>
   <note>
    <para>
     <function>str_replace</function> a &eacute;t&eacute; ajout&eacute;e
     en PHP 3.0.6, mais &eacute;tait erron&eacute;e jusqu'&agrave; PHP 3.0.8.
    </para>
   </note>
   <para>
    Voir aussi
    <function>ereg_replace</function>,
    <function>preg_replace</function> et
    <function>strtr</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.strtr">
  <refnamediv>
   <refname>strtr</refname>
   <refpurpose>
    Remplace toutes les occurrences d'un caract&egrave;re par un autre.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>strtr</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
     <methodparam><type>string</type><parameter>from</parameter></methodparam>
     <methodparam><type>string</type><parameter>to</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>strtr</function> travaille sur <parameter>str</parameter>,
    rempla&ccedil;ant chaque occurrence de chaque caract&egrave;re de la cha&icirc;ne
    <parameter>from</parameter> correspondant &agrave; la cha&icirc;ne
    <parameter>to</parameter> et retourne le r&eacute;sultat.
   </para>
   <para>
    Si <parameter>from</parameter> et <parameter>to</parameter> sont de longueurs
    diff&eacute;rentes, les caract&egrave;res en trop sont ignor&eacute;s.
    <example>
     <title>Exemple avec <function>strtr</function></title>
     <programlisting role="php">
&lt;?php
$addr = "Le g&acirc;teau au ma&iuml;s aig&uuml;";
$addr = strtr($addr, "&acirc;&iuml;&uuml;", "aiu");
print $addr;
// Affiche : "Le gateau au mais aigu"
// Note : ne cherchez pas la recette...
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    <function>strtr</function> peut aussi &ecirc;tre appel&eacute;e avec deux
    arguments. Dans ce cas, elle se comporte diff&eacute;remment :
    <parameter>from</parameter> doit &ecirc;tre un tableau associatif contenant
    des paires de cha&icirc;nes, qui seront remplac&eacute;es dans la cha&icirc;ne
    source. <function>strtr</function> recherchera toujours la cha&icirc;ne la plus
    longue, et la remplacera en premier. Elle ne remplacera jamais
    une portion de cha&icirc;ne qu'elle a d&eacute;j&agrave; remplac&eacute;.
   </para>
   <para>
    Exemples:
    <informalexample>
     <programlisting role="php">
&lt;?php
$trans = array("bonjour" =&gt; "salut", "salut" =&gt; "bonjour");
echo strtr("bonjour &agrave; tous, j'ai dit salut", $trans)."&#92;n";
?&gt;
     </programlisting>
    </informalexample>
    Cet exemple affichera : "salut &agrave; tous, j'ai dit bonjour",
   </para>
   <note>
    <simpara>
     Travailler avec deux arguments a &eacute;t&eacute; ajout&eacute; en PHP 4.0.
    </simpara>
   </note>
   <para>
    Voir aussi
    <function>ereg_replace</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.substr">
  <refnamediv>
   <refname>substr</refname>
   <refpurpose>Retourne une partie de la cha&icirc;ne.</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>substr</methodname>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
     <methodparam><type>int</type><parameter>start</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>length</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>substr</function> retourne une portion de <parameter>string</parameter>,
    sp&eacute;cifi&eacute;e avec le d&eacute;but <parameter>start</parameter> et
    la longueur <parameter>length</parameter>.
   </para>
   <para>
    Si <parameter>start</parameter> est positif, la cha&icirc;ne retourn&eacute;e
    commencera au caract&egrave;re <parameter>start</parameter> de la cha&icirc;ne
    <parameter>string</parameter>. Par exemple, dans la cha&icirc;ne
    '<literal>abcdef</literal>', le caract&egrave;re &agrave; la position 0 est
    '<literal>a</literal>', le caract&egrave;re &agrave; la position <literal>2</literal> est
    '<literal>c</literal>', et ainsi de suite. Par exemple:
   </para>
   <para>
    <informalexample>
     <programlisting role="php">
&lt;?php
  $reste = substr("abcdef", 1);    // retourne "bcdef"
  $reste = substr("abcdef", 1, 3); // retourne "bcd"
?&gt;
     </programlisting>
    </informalexample>
   </para>
   <para>
    Si <parameter>start</parameter> est n&eacute;gatif, la cha&icirc;ne
    retourn&eacute;e commencera au caract&egrave;re <parameter>start</parameter>
    de la cha&icirc;ne <parameter>string</parameter>, en partant de la fin.
    Par exemple:
   </para>
   <para>
    <informalexample>
     <programlisting role="php">
&lt;?php
  $reste = substr("abcdef", -1);    // retourne "f"
  $reste = substr("abcdef", -2);    // retourne "ef"
  $reste = substr("abcdef", -3, 1); // retourne "d"
?&gt;
     </programlisting>
    </informalexample>
   </para>
   <para>
    Si <parameter>length</parameter> est donn&eacute; et positive,
    la cha&icirc;ne retourn&eacute;e aura la longueur <parameter>length</parameter>.
    Si <parameter>length</parameter> est donn&eacute;e et n&eacute;gative, la
    cha&icirc;ne retourn&eacute;e aura la longueur
    <parameter>length</parameter>, en partant de la fin.
   </para>
   <para>
    <informalexample>
     <programlisting role="php">
&lt;?php
  $reste = substr("abcdef", 1, -1);
  // retourne "bcde"
?&gt;
     </programlisting>
    </informalexample>
   </para>
   <para>
    Voir aussi
    <function>strrchr</function> et
    <function>ereg</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.substr-count">
  <refnamediv>
   <refname>substr_count</refname>
   <refpurpose>Compte le nombre de sous-cha&icirc;nes </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>substr_count</methodname>
     <methodparam><type>string</type><parameter>haystrack</parameter></methodparam>
     <methodparam><type>string</type><parameter>needle</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>substr_count</function> retourne le nombre de fois que
    <parameter>needle</parameter> appara&icirc;t dans <parameter>haystack</parameter>.
   </para>
   <para>
    <example>
     <title>Exemple <function>substr_count</function></title>
     <programlisting role="php">
&lt;?php
print substr_count("Ceci est un test", "es"); // affiche 2
?&gt;
     </programlisting>
    </example>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.substr-replace">
  <refnamediv>
   <refname>substr_replace</refname>
   <refpurpose>Remplace dans une sous partie de cha&icirc;ne</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>substr_replace</methodname>
     <methodparam><type>string</type><parameter>string</parameter></methodparam>
     <methodparam><type>string</type><parameter>replacement</parameter></methodparam>
     <methodparam><type>int</type><parameter>start</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>length</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>substr_replace</function> effectue un remplacement dans la portion de
    <parameter>string</parameter> d&eacute;limit&eacute;e par le caract&egrave;re
    <parameter>start</parameter> et de longueur optionnelle
    <parameter>length</parameter>. Le remplacement est fait avec la cha&icirc;ne
    <parameter>replacement</parameter>. Le r&eacute;sultat est retourn&eacute;.
   </para>
   <para>
    Si <parameter>start</parameter> est positif, le remplacement commencera au
    caract&egrave;re <parameter>start</parameter>, dans la cha&icirc;ne
    <parameter>string</parameter>.
   </para>
   <para>
    Si <parameter>start</parameter> est n&eacute;gative, le remplacement commencera
    au caract&egrave;re <parameter>start</parameter> en partant de la fin de la
    cha&icirc;ne <parameter>string</parameter>.
   </para>
   <para>
    Si <parameter>length</parameter> est donn&eacute; et positif, la cha&icirc;ne
    retourn&eacute;e aura la longueur <parameter>length</parameter>. Si
    <parameter>length</parameter> est donn&eacute; et n&eacute;gatif, la
    cha&icirc;ne retourn&eacute;e aura la longueur <parameter>length</parameter>,
    en partant de la fin. Par d&eacute;faut, il prendra la valeur de
    strlen(<parameter>string</parameter> ); c'est-&agrave;-dire qu'il remplacera
    jusqu'&agrave; la fin de la cha&icirc;ne <parameter>string</parameter>.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>substr_replace</function></title>
     <programlisting role="php">
&lt;?php
$var = 'ABCDEFGH:/MNRPQR/';
echo "Original: $var&lt;hr&gt;&#92;n";
/* Ces deux exemples remplacent tout $var avec 'bob'. */
echo substr_replace($var, 'bob', 0)."&lt;br&gt;&#92;n";
echo substr_replace($var, 'bob', 0, strlen($var))."&lt;br&gt;&#92;n";
/* Ins&egrave;re 'bob' &agrave; gauche, du d&eacute;but de $var. */
echo substr_replace($var, 'bob', 0, 0)."&lt;br&gt;&#92;n";
/* Ces deux exemples remplacent 'MNRPQR' dans $var avec 'bob'. */
echo substr_replace($var, 'bob', 10, -1)."&lt;br&gt;&#92;n";
echo substr_replace($var, 'bob', -7, -1)."&lt;br&gt;&#92;n";
/* Efface 'MNRPQR' dans $var. */
echo substr_replace($var, '', 10, -1)."&lt;br&gt;&#92;n";
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>str_replace</function> et
    <function>substr</function>.
   </para>
   <note>
    <simpara>
     <function>substr_replace</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.0.
    </simpara>
   </note>
  </refsect1>
 </refentry>
 <refentry id="function.trim">
  <refnamediv>
   <refname>trim</refname>
   <refpurpose>
    Enl&egrave;ve les espaces de d&eacute;but et de fin de cha&icirc;ne
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>trim</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>trim</function> retire les espaces blancs de d&eacute;but et de
    fin de cha&icirc;ne, et  retourne la cha&icirc;ne nettoy&eacute;e. Les
    espaces blancs sont : "&#92;n", "&#92;r", "&#92;t", "&#92;v", "&#92;0", et " " (espace).
   </para>
   <para>
    Voir aussi
    <function>chop</function> et
    <function>ltrim</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.ucfirst">
  <refnamediv>
   <refname>ucfirst</refname>
   <refpurpose>
    Force le premier caract&egrave;re d'une cha&icirc;ne en majuscule.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>ucfirst</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>ucfirst</function> met le premier caract&egrave;re
    d'une cha&icirc;ne <parameter>str</parameter> en majuscules, si
    ce caract&egrave;re est alphab&eacute;tique.
   </para>
   <para>
    Notez que le caract&egrave;re 'alphab&eacute;tique' est d&eacute;termin&eacute;
    par la table de caract&egrave;res locale. Par exemple, dans la table des
    caract&egrave;res par d&eacute;faut du "C", des caract&egrave;res tels que
    a-umlaut (&auml;) ne seront pas convertis.
    <example>
     <title>Exemple avec <function>ucfirst</function></title>
     <programlisting role="php">
&lt;?php
$text = 'marie a un petit agneau, et l'adore.';
$text = ucfirst($text); // $text vaut : Marie a un petit agneau, et l'adore
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>strtoupper</function> et
    <function>strtolower</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.ucwords">
  <refnamediv>
   <refname>ucwords</refname>
   <refpurpose>
    Force le premier caract&egrave;re de chaque mot d'une cha&icirc;ne en majuscule
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>ucwords</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>ucwords</function> met le premier caract&egrave;re de chaque mot
    de la cha&icirc;ne <parameter>str</parameter> si ce caract&egrave;re est une
    lettre.
    <example>
     <title>Exemple avec <function>ucwords</function></title>
     <programlisting role="php">
&lt;?php
$text = "marie a un petit agneau, et l'adore.";
$text = ucwords($text); // $text vaut : Marie A Un Petit Agneau, Et l'Adore.
?&gt;
     </programlisting>
    </example>
   </para>
   <note>
    <simpara>
     La d&eacute;finition d'un mot est : une cha&icirc;ne de caract&egrave;res
     imm&eacute;diatement apr&egrave;s un caract&egrave;re blanc (c'est-&agrave;-dire :
     espace, form-feed, nouvelle ligne, retour chariot, tabulation horizontale,
     et tabulation verticale).
    </simpara>
   </note>
   <para>
    Voir aussi
    <function>strtoupper</function>,
    <function>strtolower</function> et
    <function>ucfirst</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.wordwrap">
  <refnamediv>
   <refname>wordwrap</refname>
   <refpurpose>
    Ajoute une c&eacute;sure &agrave; une cha&icirc;ne tous les n caract&egrave;res
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>string</type><methodname>wordwrap</methodname>
     <methodparam><type>string</type><parameter>str</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>width</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>break</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>cut</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>wordwrap</function> ajoute la c&eacute;sure <parameter>str</parameter>
    au num&eacute;ro de colonne <parameter>width</parameter>. La ligne est
    c&eacute;sur&eacute;e avec la cha&icirc;ne <parameter>break</parameter>.
   </para>
   <para>
    <function>wordwrap</function> ajoute la c&eacute;sure automatiquement
    &agrave; la ligne 75 et utilise '<literal>&#92;n</literal>' (nouvelle ligne) si
    <parameter>width</parameter> ou <parameter>break</parameter> sont omis.
   </para>
   <para>
    Si <parameter>cut</parameter> vaut 1, la cha&icirc;ne sera toujours
    coup&eacute;e &agrave; la taille sp&eacute;cifi&eacute;e. Dans ce cas,
    les mots qui d&eacute;passeront, seront coup&eacute;s :
    voyez le second exemple.
   </para>
   <note>
    <para>
     Le param&egrave;tre <parameter>cut</parameter> a &eacute;t&eacute;
     ajout&eacute; dans  PHP 4.0.3.
    </para>
   </note>
   <para>
    <example>
     <title>Exemple <function>wordwrap</function></title>
     <programlisting role="php">
&lt;?php
$text = "Ma&icirc;tre corbeau jura, mais un peu tard, qu'on ne l'y prendrait plus.";
$newtext = wordwrap( $text, 20 );
echo "$newtext&#92;n";
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Cet exemple va afficher :
   </para>
   <para>
    <informalexample>
     <literallayout>
       <computeroutput>
Ma&icirc;tre corbeau
 jura, mais un peu t
ard, qu'on ne l'y pr
endrait plus.
       </computeroutput>
     </literallayout>
    </informalexample>
   </para>
   <para>
    <example>
     <title>Exemple avec <function>wordwrap</function></title>
     <programlisting role="php">
&lt;?php
$text = "Un tr&egrave;s tr&egrave;s long mooooooooooooooooooooooooot.";
$newtext = wordwrap( $text, 8, "&#92;n", 1);
echo "$newtext&#92;n";
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Cet exemple va afficher
   </para>
   <para>
    <informalexample>
     <literallayout>
       <computeroutput>
Un tr&egrave;s
tr&egrave;s
long
mooooooo
oooooooo
oooooooo
oot.
       </computeroutput>
     </literallayout>
    </informalexample>
   </para>
   <para>
    Voir aussi
    <function>nl2br</function>.
   </para>
  </refsect1>
 </refentry>
</reference>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->