<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision: 1.46 $ -->
<reference id="ref.array">
 <title>Tableaux</title>
 <titleabbrev>Tableaux</titleabbrev>
 <partintro>
  <simpara>
   Ces fonctions vous permettent de manipuler et de traiter les tableaux
   de nombreuses fa&ccedil;ons. Les tableaux sont tr&egrave;s efficaces 
   d&egrave;s qu'il s'agit de stocker, g&eacute;rer et traiter des
   donn&eacute;es en groupe.
  </simpara>
  <simpara>
   Les tableaux simples et multi-dimensionnels sont support&eacute;s et peuvent
   &ecirc;tre cr&eacute;&eacute;s par l'utilisateur, ou par une fonction. Il y a
   des fonctions sp&eacute;cifiques qui remplissent des tableaux &agrave; partir
   de r&eacute;sultats de requ&ecirc;tes, et de nombreuses fonctions retournent
   un tableau.
  </simpara>
  <para>
   Voir aussi
   <function>is_array</function>,
   <function>explode</function>,
   <function>implode</function>,
   <function>split</function> et
   <function>join</function>.
  </para>
 </partintro>
 <refentry id="function.array">
  <refnamediv>
   <refname>array</refname>
   <refpurpose>
    Cr&eacute;e un tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array</methodname>
     <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array</function> retourne un tableau cr&eacute;&eacute; avec les
    param&egrave;tres pass&eacute;s. On peut attribuer un index particulier
    &agrave; une valeur avec l'op&eacute;rateur <literal>=?&gt;</literal>.
   </para>
   <para>
    <note>
     <para>
      <function>array</function> est un &eacute;l&eacute;ment de langage
      utilis&eacute; pour repr&eacute;senter des tableaux lit&eacute;raux,
      et non pas une fonction au sens strict du terme.
     </para>
    </note>
   </para>
   <para>
    La syntaxe "index =&gt; valeur", s&eacute;par&eacute;e par des virgules,
    d&eacute;finit les index et leur valeur. Un index peut &ecirc;tre une
    cha&icirc;ne ou un nombre. Si l'index est omis, un index num&eacute;rique
    sera automatiquement g&eacute;n&eacute;r&eacute; (commen&ccedil;ant &agrave;
    0). Si l'index est un entier, le prochain index g&eacute;n&eacute;r&eacute;
    prendra la valeur d'index la plus grande + 1. Notez que si deux index
    identiques sont d&eacute;finis, le dernier remplacera le premier.
   </para>
   <para>
    L'exemple suivant montre comment cr&eacute;er un tableau &agrave; deux dimensions,
    comment sp&eacute;cifier les index d'un tableau associatif, et comment
    g&eacute;n&eacute;rer automatiquement des index num&eacute;riques.
    <example>
     <title>Exemple avec <function>array</function></title>
     <programlisting role="php">
&lt;?php
  $fruits = array (
    "fruits"  =&gt; array ("a" =&gt; "orange", "b" =&gt; "banane", "c" =&gt; "pomme"),
    "numbres" =&gt; array (1, 2, 3, 4, 5, 6),
    "trous"   =&gt; array ("premier", 5 =&gt; "deuxi&egrave;me", "troisi&egrave;me")
  );
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    <example>
     <title>Index automatique d'un tableau avec <function>array</function></title>
     <programlisting role="php">
&lt;?php
  $array = array( 1, 1, 1, 1,  1, 8=&gt;1,  4=&gt;1, 19, 3=&gt;13);
  print_r($array);
?&gt;
     </programlisting>
    </example>
    qui affichera :
    <informalexample>
     <programlisting>
Array
(
    [0] =&gt; 1
    [1] =&gt; 1
    [2] =&gt; 1
    [3] =&gt; 13
    [4] =&gt; 1
    [8] =&gt; 1
    [9] =&gt; 19
)
     </programlisting>
    </informalexample>
   </para>
   <para>
    Notez bien que l'index '3' est d&eacute;fini deux fois, et conserve finalement
    sa derni&egrave;re valeur de 13. L'index '4' est d&eacute;fini apr&egrave;s
    l'index '8', et l'index g&eacute;n&eacute;r&eacute; suivant (valeur 19) est
    9, puisque le plus grand index est alors 8.
   </para>
   <para>
    Cet exemple cr&eacute;e un tableau dont les index commencent &agrave; 1.
    <example>
     <title>Tableau d'index commen&ccedil;ant &agrave; 1</title>
     <programlisting role="php">
&lt;?php
  $firstquarter  = array(1 =&gt; 'Janvier', 'F&eacute;vrier', 'Mars');
  print_r($firstquarter);
?&gt;
     </programlisting>
    </example>
    qui affichera :
    <informalexample>
     <screen>
     Array
     (
     [1] =&gt; 'Janvier'
     [2] =&gt; 'F&eacute;vrier'
     [3] =&gt; 'Mars'
     )
     </screen>
    </informalexample>
   </para>
   <para>
    Voir aussi
    <function>list</function>.
   </para>
  </refsect1>
 </refentry>
  <!--
  <refentry id="function.array-change-key-case">
   <refnamediv>
    <refname>array_change_key_case</refname>
    <refpurpose>
     Retourne un tableau dont toutes les cl&eacute;s ont &eacute;t&eacute; forc&eacute;es en
     majuscules ou minuscules.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>array_change_key_case</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>case</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_change_key_case</function> modifie les cl&eacute;s du
     tableau <parameter>input</parameter>, et force leur type.
     Le param&egrave;tre optionnel <parameter>case</parameter>
     permet de forcer les cha&icirc;nes de caract&egrave;res en majuscules
     <constant>CASE_UPPER</constant> ou minuscules
     <constant>CASE_LOWER</constant>. La valeur par d&eacute;faut
     est <constant>CASE_LOWER</constant>. Cette fonction
     laissera les cl&eacute;s num&eacute;riques inchang&eacute;es.
    </para>
    <para>
     <example>
      <title>Exemple avec <function>array_change_key_case</function></title>
      <programlisting role="php">
&lt;?php
$input_array = array("PrEmIEr" => 1, "SecOnd" => 2);
print_r(array_change_key_case($input_array, CASE_UPPER);
?&gt;
      </programlisting>
     </example>     
     L'exemple ci-dessus va afficher : 
     <informalexample>
      <programlisting>
Array
(
    [PREMIER] => 1
    [SECOND] => 2
)

      </programlisting>
     </informalexample>
    </para>
   </refsect1>
  </refentry>
  -->
  <refentry id="function.array-chunk">
   <refnamediv>
    <refname>array_chunk</refname>
    <refpurpose>S&eacute;pare un tableau en tableaux de taille inf&eacute;rieure</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>array_chunk</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
      <methodparam><type>int</type><parameter>size</parameter></methodparam>
      <methodparam choice="opt"><type>bool</type><parameter>preserve_keys</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_chunk</function> s&eacute;pare le tableau
     <parameter>input</parameter> en plusieurs tableaux de taille
     <parameter>size</parameter>. Il est aussi possible que le
     dernier tableau ait moins de valeurs. Le r&eacute;sultat est un
     tableau multidimensionnel, index&eacute; num&eacute;riquement.
    </para>
    <para>
     En passant la valeur &true; au param&egrave;tre optionnel
     <parameter>preserve_keys</parameter>, vous pouvez forcer
     PHP &agrave; pr&eacute;server les cl&eacute;s originales du tableau
     <parameter>input</parameter>. Si vous utilisez la valeur
     par d&eacute;faut (&false;), de nouveaux index num&eacute;riques seront
     fournis, commencant &agrave; 0.
    </para>
    <para>
     <example>
      <title>Exemple avec <function>array_chunk</function></title>
      <programlisting role="php">
&lt;?php
$input_array = array('a', 'b', 'c', 'd', 'e');
print_r(array_chunk($input_array, 2));
print_r(array_chunk($input_array, 2, TRUE));
?&gt;
      </programlisting>
     </example>     
      L'exemple ci-dessus va afficher : 
     <informalexample>
      <programlisting>
Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
        )

    [1] => Array
        (
            [0] => c
            [1] => d
        )

    [2] => Array
        (
            [0] => e
        )

)
Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
        )

    [1] => Array
        (
            [2] => c
            [3] => d
        )

    [2] => Array
        (
            [4] => e
        )

)
      </programlisting>
     </informalexample>
    </para>
   </refsect1>
  </refentry>
 <refentry id="function.array-count-values">
  <refnamediv>
   <refname>array_count_values</refname>
   <refpurpose>Compte le nombre de valeurs dans un tableau</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_count_values</methodname>
     <methodparam><type>array</type><parameter>input</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_count_values</function> retourne un tableau contenant
    les valeurs du tableau <parameter>input</parameter> comme cl&eacute;s
    et leurs fr&eacute;quence comme valeur.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_count_values</function></title>
     <programlisting role="php">
&lt;?php
  $array = array(1, "bonjour", 1, "monde", "bonjour");
  array_count_values($array); 
// retourne array(1=&gt;2, "bonjour"=&gt;2, "monde"=&gt;1)
?&gt;
     </programlisting>
    </example>
    <note>
     <para>
      <function>array_count_values</function> a &eacute;t&eacute; ajout&eacute;e
      en PHP 4.0.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-diff">
  <refnamediv>
   <refname>array_diff</refname>
   <refpurpose>Calcule la diff&eacute;rence entre deux tableaux</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_diff</methodname>
     <methodparam><type>array</type><parameter>array1</parameter></methodparam>
     <methodparam><type>array</type><parameter>array2</parameter></methodparam>
     <methodparam choice="opt"><type>array</type><parameter>...</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_diff</function> retourne un tableau
    qui contient toutes les valeurs du tableau <parameter>array1</parameter>
    qui sont absentes de tous les autres arguments.
    Notez que les cl&eacute;s sont pr&eacute;serv&eacute;es.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_diff</function></title>
     <programlisting role="php">
&lt;?php
  $array1 = array ("a" =&gt; "vert", "rouge", "bleu", "rouge");
  $array2 = array ("b" =&gt; "vert", "jaune", "rouge");
  $result = array_diff ($array1, $array2);
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    <varname>$result</varname> contient <literal>array("bleu");</literal>.
    Les valeurs multiples dans $array1 seront toutes trait&eacute;es de la 
    m&ecirc;me fa&ccedil;on.
   </para>
    <note>
     <simpara>
      Deux &eacute;l&eacute;ments sont consid&eacute;r&eacute;s comme &eacute;gaux si et seulement si 
      <literal>(string) $elem1 === (string) $elem2</literal>. En clair :
      lorsque la repr&eacute;sentation en cha&icirc;ne de caract&egrave;res est identique.
      <!-- TODO: example of it... -->
     </simpara>
    </note>
    <warning>
     <simpara>
      Cette fonction &eacute;tait inutilisable en PHP 4.0.4!
      <!-- TODO: when exactly was this broken?... -->
     </simpara>
    </warning>
   <para>
    Voir aussi
    <function>array_intersect</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-filter">
  <refnamediv>
   <refname>array_filter</refname>
   <refpurpose>Filtre les &eacute;l&eacute;ments d'un tableau</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_filter</methodname>
     <methodparam><type>array</type><parameter>input</parameter></methodparam>
     <methodparam choice="opt"><type>mixed</type><parameter>callback</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_filter</function> retourne un tableau
    contenant les &eacute;l&eacute;ments du tableau <parameter>input</parameter>,
    filtr&eacute;s gr&acirc;ce &agrave; la fonction <parameter>callback</parameter>.
    Si <parameter>input</parameter> est un tableau associatif,
    les cl&eacute;s sont pr&eacute;serv&eacute;es.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_filter</function></title>
     <programlisting role="php">
&lt;?php
  function pair($var) {
   return ($var % 2 == 1);
  }
  function impair($var) {
   return ($var % 2 == 0);
  }
  $array1 = array("a"=&gt;1, "b"=&gt;2, "c"=&gt;3, "d"=&gt;4, "e"=&gt;5);
  $array2 = array(6, 7, 8, 9, 10, 11, 12);
  $tableau_pair = array_filter($array1, "pair");
  $tableau_impair = array_filter($array2, "impair");
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Cet exemple montre comment extraire les nombres pairs
    dans <varname>$tableau_impair</varname> : ce dernier contient
    <literal>array ("a"=&gt;1, "c"=&gt;3, "e"=&gt;5);</literal>,
    et les nombres impairs dans <varname>$tableau_pair</varname> :
    ce dernier contient <literal>array (6, 8, 10, 12);</literal>,
   </para>
   <para>
    Voir aussi
    <function>array_map</function> et
    <function>array_reduce</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-flip">
  <refnamediv>
   <refname>array_flip</refname>
   <refpurpose>
    Remplace les cl&eacute;s par les valeurs, et les valeurs par les cl&eacute;s
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_flip</methodname>
     <methodparam><type>array</type><parameter>trans</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_flip</function> retourne un tableau dont les
    cl&eacute;s sont les valeurs du pr&eacute;c&eacute;dent tableau,
    et les valeurs sont les cl&eacute;s. <function>array_flip</function>
    ne fonctionne que sur des entiers et des cha&icirc;nes, et affichera une
    erreur s'il d&eacute;tecte une cl&eacute; ou une valeur de type invalide
    (tableau, objet, bool&eacute;en, nombre &agrave; virgule flottante).
   </para>
   <para>
    Notez bien que les valeurs de <parameter>trans</parameter> doivent 
    &ecirc;tre des cl&eacute;s valides, c'est &agrave; dire qu'elles doivent &ecirc;tre des
    entiers (<type>integer</type>) ou des cha&icirc;nes de caract&egrave;res 
    (<type>string</type>). Une alerte sera &eacute;mise si une valeur a un type qui 
    ne convient pas et la paire en question <emphasis>ne sera pas
    invers&eacute;e</emphasis>.
   </para>
   <para>
    Si une valeur n'est pas unique, seule la derni&egrave;re cl&eacute; sera
    utilis&eacute;e comme valeur, et toutes les autres seront perdues.
   </para>
   <para>
    <function>array_flip</function> retourne &false;
    en cas d'&eacute;chec.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_flip</function></title>
     <programlisting role="php">
&lt;?php
  $trans = array_flip ($trans);
  $original = strtr ($str, $trans);
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    <example>
     <title><function>array_flip</function> example : collision</title>
     <programlisting role="php">
&lt;?php
  $trans = array ("a" => 1, "b" => 1, "c" => 2);
  $trans = array_flip ($trans);
// et $trans vaut : array(1 => "b", 2 => "c");
?&gt;
     </programlisting>
    </example>
   </para>
   <note>
    <para>
     <function>array_flip</function> a &eacute;t&eacute; ajout&eacute;e
     en PHP 4.0.
    </para>
   </note>
  </refsect1>
 </refentry>
  <refentry id="function.array-fill">
   <refnamediv>
    <refname>array_fill</refname>
    <refpurpose>Remplis un tableau avec une m&ecirc;me valeur</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>array_fill</methodname>
      <methodparam><type>int</type><parameter>start_index</parameter></methodparam>
      <methodparam><type>int</type><parameter>num</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>value</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_fill</function> cr&eacute;e un tableau avec
     <parameter>num</parameter> entr&eacute;es de la valeur 
     <parameter>value</parameter>. Les index commecent &agrave; la valeur
     <parameter>start_index</parameter>.
    </para>
    <para>
     <example>
      <title>Exemple avec <function>array_fill</function></title>
      <programlisting role="php">
&lt;?gt;
$a = array_fill(5, 6, 'banane');

/*
$a est le tableau suivant

$a[5]  = "banane";
$a[6]  = "banane";
$a[7]  = "banane";
$a[8]  = "banane";
$a[9]  = "banane";
$a[10] = "banane";
*/
?&gt;
      </programlisting>
     </example>     
    </para>
   </refsect1>
  </refentry>
 <refentry id="function.array-intersect">
  <refnamediv>
   <refname>array_intersect</refname>
   <refpurpose>Calcule l'intersection de tableaux</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_intersect</methodname>
     <methodparam><type>array</type><parameter>array1</parameter></methodparam>
     <methodparam><type>array</type><parameter>array2</parameter></methodparam>
     <methodparam choice="opt"><type>array</type><parameter>...</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_intersect</function> retourne un tableau
    contenant toutes les valeurs de <parameter>array1</parameter>
    qui sont pr&eacute;sentes dans tous les autres arguments.
    Notez que les cl&eacute;s sont pr&eacute;serv&eacute;es.
   </para>
    <note>
     <simpara>
      Deux &eacute;l&eacute;ments sont consid&eacute;r&eacute;s comme &eacute;gaux si et seulement si 
      <literal>(string) $elem1 === (string) $elem2</literal>. En clair :
      lorsque la repr&eacute;sentation en cha&icirc;ne de caract&egrave;res est identique.
      <!-- TODO: example of it... -->
     </simpara>
    </note>
    <warning>
     <simpara>
      Cette fonction &eacute;tait inutilisable en PHP 4.0.4!
      <!-- TODO: when exactly was this broken?... -->
     </simpara>
    </warning>
    <para>
    <example>
     <title>Exemple avec <function>array_intersect</function></title>
     <programlisting role="php">
&lt;?php
  $array1 = array ("a" =&gt; "vert", "rouge", "bleu");
  $array2 = array ("b" =&gt; "vert", "jaune", "rouge");
  $result = array_intersect ($array1, $array2);
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    <varname>$result</varname> contient <literal>array ("a" =&gt; "vert",
    "rouge");</literal>.
   </para>
   <para>
    Voir aussi
    <function>array_diff</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-keys">
  <refnamediv>
   <refname>array_keys</refname>
   <refpurpose>Retourne toutes les cl&eacute;s d'un tableau</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_keys</methodname>
     <methodparam><type>array</type><parameter>input</parameter></methodparam>
     <methodparam choice="opt"><type>mixed</type><parameter>
      search_value
      </parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_keys</function> retourne les cl&eacute;s num&eacute;riques
    et lit&eacute;rales du tableau <parameter>input</parameter>.
   </para>
   <para>
    Si l'option <parameter>search_value</parameter> est sp&eacute;cifi&eacute;e,
    seules les cl&eacute;s ayant cette valeur seront retourn&eacute;es.
    Sinon, toutes les cl&eacute;s de <parameter>input</parameter> sont
    retourn&eacute;es.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_keys</function></title>
     <programlisting role="php">
&lt;?php
  $array = array(0 =&gt; 100, "couleur" =&gt; "rouge");
  array_keys($array);
// retourne array(0, "couleur")
  $array = array("bleu", "rouge", "vert", "bleu", "bleu");
  array_keys($array, "bleu");
//  retourne  array(0, 3, 4)
  $array = array( "couleur" =&gt; array("bleu", "rouge", "vert"),
                "taille"  =&gt; array("petit", "moyen", "grand") );
  array_keys($array);
//  retourne array("couleur", "taille")
?&gt;
     </programlisting>
    </example>
   </para>
   <note>
    <para>
     <function>array_keys</function> a &eacute;t&eacute; ajout&eacute;e en PHP
     4. Ci-dessous, voici une impl&eacute;mentation qui fonctionnera sous PHP 3:
     <example>
      <title>
       Impl&eacute;mentation de <function>array_keys</function> pour
       les utilisateurs de  PHP 3
      </title>
      <programlisting role="php">
&lt;?php
  function array_keys ($arr, $term="") {
    $t = array();
    while (list($k,$v) = each($arr)) {
        if ($term &amp;&amp; $v != $term) {
            continue;
            $t[] = $k;
        }
        return $t;
     }
  }
?&gt;
      </programlisting>
     </example>
    </para>
   </note>
   <para>
    Voir aussi
    <function>array_values</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-map">
  <refnamediv>
   <refname>array_map</refname>
   <refpurpose>Applique sur fonction sur des tableaux</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_map</methodname>
     <methodparam><type>mixed</type><parameter>callback</parameter></methodparam>
     <methodparam><type>array</type><parameter>arr1</parameter></methodparam>
     <methodparam choice="opt"><type>array</type><parameter>...</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_map</function> retourne un tableau
    contenant tous les &eacute;l&eacute;ments du tableau <parameter>arr1</parameter>,
    apr&egrave;s leur avoir appliqu&eacute; la fonction <parameter>callback</parameter>.
    Le nombre de param&egrave;tres de la fonction <parameter>callback</parameter>
    doit &ecirc;tre &eacute;gal au nombre de tableaux pass&eacute;s dans la fonction
    <function>array_map</function>.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_map</function></title>
     <programlisting role="php">
&lt;?php
  function cube($n) {
      return $n*$n*$n;
  }
  $a = array(1, 2, 3, 4, 5);
  $b = array_map("cube", $a);
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Avec cet exemple, la variable <varname>$b</varname> contiendra
    <literal>array (1, 8, 27, 64, 125);</literal>.
   </para>
   <para>
    <example>
     <title><function>array_map</function> - utilisation de plusieurs tableaux</title>
     <programlisting role="php">
&lt;?php
  function parle_espagnol($n, $m) {
      return "Le nombre $n se dit $m en espagnol";
  }
  function map_espagnol($n, $m) {
   return array($n => $m);
  }
  $a = array(1, 2, 3, 4, 5);
  $b = array("uno", "dos", "tres", "cuatro", "cinco");
  $c = array_map("parle_espagnol", $a, $b);
  print_r($c);
// Affichera :
// Array
// (
//     [0] => Le nombre 1 se dit uno en espagnol
//     [1] => Le nombre 2 se dit dos en espagnol
//     [2] => Le nombre 3 se dit tres en espagnol
//     [3] => Le nombre 4 se dit cuatro en espagnol
//     [4] => Le nombre 5 se dit cinco en espagnol
// )
  $d = array_map("map_espagnol", $a , $b);
  print_r($d);
// Affichera :
// Array
// (
//     [0] => Array
//         (
//             [1] => uno
//         )
//
//     [1] => Array
//         (
//             [2] => dos
//         )
//
//     [2] => Array
//         (
//             [3] => tres
//         )
//
//     [3] => Array
//         (
//             [4] => cuatro
//         )
//
//     [4] => Array
//         (
//             [5] => cinco
//         )
//
// )
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    G&eacute;n&eacute;ralement, lorsque vous utilisez plusieurs tableaux, ils doivent
    &ecirc;tre de m&ecirc;me longueur, car la fonction de callback est appliqu&eacute; &agrave;
    un &eacute;l&eacute;ment de chaque tableau. Si les tableaux sont de taille in&eacute;gale,
    les plus petits seront compl&eacute;t&eacute;s avec des &eacute;l&eacute;ments vides.
   </para>
   <para>
    Une utilisation interessante de cette fonction est de construire des
    tableaux de tableaux, gr&acirc;ce &agrave; la fonction de callback &null;.
   </para>
   <para>
    <example>
     <title><function>array_map</function> - cr&eacute;ation d'un tableau de tableaux</title>
     <programlisting role="php">
&lt;?php
  $a = array(1, 2, 3, 4, 5);
  $b = array("un", "deux", "trois", "quatre", "cinq");
  $c = array("uno", "dos", "tres", "cuatro", "cinco");
  $d = array_map(null, $a, $b, $c);
  print_r($d);
// affichera :
// Array
// (
//     [0] => Array
//         (
//             [0] => 1
//             [1] => un
//             [2] => uno
//         )
//
//     [1] => Array
//         (
//             [0] => 2
//             [1] => deux
//             [2] => dos
//         )
//
//     [2] => Array
//         (
//             [0] => 3
//             [1] => trois
//             [2] => tres
//         )
//
//     [3] => Array
//         (
//             [0] => 4
//             [1] => quatre
//             [2] => cuatro
//         )
//
//     [4] => Array
//         (
//             [0] => 5
//             [1] => cinq
//             [2] => cinco
//         )
//
// )
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>array_filter</function> et
    <function>array_reduce</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-merge">
  <refnamediv>
   <refname>array_merge</refname>
   <refpurpose>Rassemble plusieurs tableaux</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_merge</methodname>
     <methodparam><type>array</type><parameter>array1</parameter></methodparam>
     <methodparam><type>array</type><parameter>array2</parameter></methodparam>
     <methodparam choice="opt"><type>array</type><parameter>...</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_merge</function> rassemble les &eacute;l&eacute;ments de
    plusieurs tableaux ensembles, en ajoutant les valeurs de l'un &agrave; la
    fin de l'autre. Le r&eacute;sultat est un tableau.
   </para>
   <para>
    Si les tableaux ont des cl&eacute;s en commun, la derni&egrave;re valeur
    rencontr&eacute;e &eacute;crasera l'ancienne. Pour les valeurs num&eacute;riques,
    cela n'arrive pas, car alors, les valeurs sont ajout&eacute;es en fin de
    tableau.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_merge</function></title>
     <programlisting role="php">
&lt;?php
  $array1 = array ("couleur" =&gt; "rouge", 2, 4);
  $array2 = array ("a", "b", "couleur" =&gt; "vert", "forme" =&gt; "trap&eacute;zo&iuml;de");
  array_merge ($array1, $array2);
?&gt;
     </programlisting>
     <para>
      Le r&eacute;sultat sera array("couleur" =&gt; "vert", 2, 4, "a",
      "b", "forme" =&gt; "trap&eacute;zo&icirc;de").
     </para>
    </example>
    <note>
     <para>
      <function>array_merge</function> a &eacute;t&eacute; ajout&eacute;e dans
      PHP 4.0.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-merge-recursive">
  <refnamediv>
   <refname>array_merge_recursive</refname>
   <refpurpose>Combine plusieurs tableaux ensembles, r&eacute;cursivement</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_merge_recursive</methodname>
     <methodparam><type>array</type><parameter>array1</parameter></methodparam>
     <methodparam><type>array</type><parameter>array2</parameter></methodparam>
     <methodparam choice="opt"><type>array</type><parameter>...</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_merge_recursive</function> rassemble tous les
    &eacute;l&eacute;ments de plusieurs tableaux ensembles, en ajoutant les
    &eacute;l&eacute;ments de l'un &agrave; la suite des
    &eacute;l&eacute;ments du pr&eacute;c&eacute;dent.
    <function>array_merge_recursive</function> retourne le tableau
    r&eacute;sultant.
   </para>
   <para>
    Si les tableaux pass&eacute;s en arguments ont les m&ecirc;mes cl&eacute;s
    (cha&icirc;nes de caract&egrave;res), les valeurs sont alors
    rassembl&eacute;es dans un tableau, de mani&egrave;re r&eacute;cursive,
    de fa&ccedil;on &agrave; ce que, si l'une de ces valeurs est un tableau
    elle-m&ecirc;me, la fonction la rassemblera avec les valeurs de
    l'entr&eacute;e courante. Cependant, si deux tableaux ont la m&ecirc;me
    cl&eacute; num&eacute;rique, la derni&egrave;re valeur n'&eacute;crasera
    pas la pr&eacute;c&eacute;dente, mais sera ajout&eacute;e &agrave; la fin
    du tableau.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_merge_recursive</function></title>
     <programlisting role="php">
&lt;?php
  $ar1 = array ("couleur" =&gt; array ("favorie" ?&gt; "rouge"), 5);
  $ar2 = array (10, "couleur" ?&gt; array ("favorie" ?&gt; "vert", "rouge"));
  $result = array_merge_recursive ($ar1, $ar2);
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Le r&eacute;sultat sera
    <literal>array("couleur" =&gt; array("favorie" =&gt; array ("rouge", "vert"), "bleu"), 5, 10)</literal>.
   </para>
   <para>
    Voir aussi
    <function>array_merge</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-multisort">
  <refnamediv>
   <refname>array_multisort</refname>
   <refpurpose>Tri multi-dimensionnel</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>boolean</type><methodname>array_multisort</methodname>
     <methodparam><type>array</type><parameter>ar1</parameter></methodparam>
     <methodparam choice="opt"><type>mixed</type><parameter>arg</parameter></methodparam>
     <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
     <methodparam choice="opt"><type>array</type><parameter>...</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_multisort</function> sert &agrave; trier simultan&eacute;ment
    plusieurs tableaux, ou bien &agrave; trier un tableau multi-dimensionnel,
    suivant l'une ou l'autre de ses dimensions. Les cl&eacute;s sont
    pr&eacute;serv&eacute;es.
   </para>
   <para>
    Les tableaux pass&eacute;s en arguments sont trait&eacute;s comme les colonnes
    d'une table, tri&eacute;es par lignes (un peu comme la clause SQL ORDER BY).
    Le premier tableau est la cl&eacute; primaire de tri. Les valeurs du premier
    tableau qui sont &eacute;gales, sont tri&eacute;es gr&acirc;ce au tableau suivant,
    et ainsi de suite...
   </para>
   <para>
    La structure des arguments de <function>array_multisort</function> est un peu
    inhabituelle, mais elle est plus souple. Le premier argument DOIT &ecirc;tre
    un tableau, mais les arguments suivants peuvent &ecirc;tre des tableaux ou
    une ou deux options de tri, prises dans les valeurs suivantes :
   </para>
   <para>
    Options de tri :
    <itemizedlist>
     <listitem>
      <simpara>SORT_ASC - Tri en ordre ascendant</simpara>
     </listitem>
     <listitem>
      <simpara>SORT_DESC - Tri en ordre descendant</simpara>
     </listitem>
    </itemizedlist>
   </para>
   <para>
    Options de type de tri:
    <itemizedlist>
     <listitem>
      <simpara>SORT_REGULAR - Comparaison normale des valeurs</simpara>
     </listitem>
     <listitem>
      <simpara>SORT_NUMERIC - Comparaison num&eacute;rique des valeurs</simpara>
     </listitem>
     <listitem>
      <simpara>SORT_STRING - Comparaison alphab&eacute;tique des valeurs</simpara>
     </listitem>
    </itemizedlist>
   </para>
   <para>
    Une seule option de tri de chaque type peut &ecirc;tre appliqu&eacute;e
    apr&egrave;s un tableau. Une option ne s'applique qu'au tableau
    pr&eacute;c&eacute;dent. Tous les autres sont mis par d&eacute;faut
    &agrave; SORT_ASC et SORT_REGULAR.
   </para>
   <para>
    <function>array_multisort</function> retourne &true;
    en cas de succ&egrave;s, &false; sinon.
   </para>
   <para>
    <example>
     <title>Trier plusieurs tableaux</title>
     <programlisting role="php">
&lt;?php
  $ar1 = array ("10", 100, 100, "a");
  $ar2 = array (1, 3, "2", 1);
  array_multisort ($ar1, $ar2);
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Dans cet exemple, apr&egrave;s le tri, le premier
    tableau contient 10, "a", 100, 100; Le deuxi&egrave;me tableau
    contient 1, 1, "2", 3. Les entr&eacute;es du second tableau
    correspondant aux valeurs jumelles du premier
    tableau (100 et 100), sont aussi tri&eacute;es.
   </para>
   <para>
    <example>
     <title>Classer un tableau multidimensionnel</title>
     <programlisting role="php">
&lt;?php
  $ar = array (array ("10", 100, 100, "a"), array (1, 3, "2", 1));
  array_multisort ($ar[0], SORT_ASC, SORT_STRING,
                 $ar[1], SORT_NUMERIC, SORT_DESC);
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Dans cet exemple, apr&egrave;s le tri, le premier tableau contient
    10, 100, 100, "a" (tri alphab&eacute;tique, ordre croissant); Le
    deuxi&egrave;me tableau contient 1, 3, "2", 1 (tri
    num&eacute;rique, ordre d&eacute;croissant).
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-pad">
  <refnamediv>
   <refname>array_pad</refname>
   <refpurpose>
    Compl&egrave;te un tableau jusqu'&agrave; la longueur sp&eacute;cifi&eacute;e,
    avec une valeur.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_pad</methodname>
     <methodparam><type>array</type><parameter>input</parameter></methodparam>
     <methodparam><type>int</type><parameter>pad_size</parameter></methodparam>
     <methodparam><type>mixed</type><parameter>pad_value</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_pad</function> retourne une copie du tableau
    <parameter>input</parameter> compl&eacute;t&eacute; jusqu'&agrave; la taille de
    <parameter>pad_size</parameter> avec la valeur
    <parameter>pad_value</parameter>. Si <parameter>pad_size</parameter> est positif,
    alors le tableau est compl&eacute;t&eacute; &agrave; droite, s'il est
    n&eacute;gatif, il est compl&eacute;t&eacute; &agrave; gauche. Si la valeur
    absolue de <parameter>pad_size</parameter> est plus petite que la taille du
    tableau  <parameter>input</parameter>, alors le tableau n'est pas
    compl&eacute;t&eacute;.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_pad</function></title>
     <programlisting role="php">
&lt;?php
  $input = array(12, 10, 9);
  $result = array_pad($input, 5, 0);
// Le r&eacute;sultat est array (12, 10, 9, 0, 0)
  $result = array_pad($input, -7, -1);
// Le r&eacute;sultat est array (-1, -1, -1, -1, 12, 10, 9)
  $result = array_pad($input, 2, "noop");
// pas compl&eacute;t&eacute;
?&gt;
     </programlisting>
    </example>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-pop">
  <refnamediv>
   <refname>array_pop</refname>
   <refpurpose>
    D&eacute;pile un &eacute;l&eacute;ment de la fin d'un tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>array_pop</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_pop</function> d&eacute;pile et retourne le dernier
    &eacute;l&eacute;ment du tableau <parameter>array</parameter>, le
    raccourcissant d'un &eacute;l&eacute;ment. Si <parameter>array</parameter>
    est vide, ou n'est pas un tableau, <function>array_pop</function>
    retourne &null;.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_pop</function></title>
     <programlisting role="php">
&lt;?php
  $stack = array("orange", "pomme", "framboise");
  $fruit = array_pop($stack);
?&gt;
     </programlisting>
     <para>
      Apr&egrave;s ceci, $stack n'a plus que 2 &eacute;l&eacute;ments: "orange" et "pomme",
      tandis que $fruit contient "framboise".
     </para>
    </example>
   </para>
   <para>
    Voir aussi
    <function>array_push</function>,
    <function>array_shift</function> et
    <function>array_unshift</function>.
    <note>
     <para>
      <function>array_pop</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.0.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-push">
  <refnamediv>
   <refname>array_push</refname>
   <refpurpose>
    Empile un ou plusieurs &eacute;l&eacute;ments &agrave; la fin d'un tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>array_push</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
     <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
     <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_push</function> consid&egrave;re <parameter>array</parameter>
    comme une pile, et empile les variables pass&eacute;es en param&egrave;tres
    &agrave; la fin de <parameter>array</parameter>.
    La longueur du tableau <parameter>array</parameter> augmente d'autant.
    Cela a le m&ecirc;me effet que :
    <programlisting role="php">
&lt;?php
  $array[] = $var;
?&gt;
    </programlisting>
    repet&eacute; pour chaque <parameter>var</parameter>.
   </para>
   <para>
    <function>array_push</function> retourne le nouveau nombre
    d'&eacute;l&eacute;ments du tableau.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_push</function></title>
     <programlisting role="php">
&lt;?php
  $stack = array (1, 2);
  array_push($stack, "+", 3);
?&gt;
     </programlisting>
    </example>
    Cet exemple fait que $stack a 4 &eacute;l&eacute;ments: 1, 2, "+",
    et 3.
   </para>
   <para>
    Voir aussi
    <function>array_pop</function>,
    <function>array_shift</function> et
    <function>array_unshift</function>.
    <note>
     <para>
      <function>array_push</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.0.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-reverse">
  <refnamediv>
   <refname>array_reverse</refname>
   <refpurpose>
    Renverse l'ordre des &eacute;l&eacute;ments d'un tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_reverse</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
     <methodparam choice="opt"><type>boolean</type><parameter>preserve_keys</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_reverse</function> prend le tableau <parameter>array</parameter>
    et retourne un nouveau tableau qui contient les m&ecirc;mes &eacute;l&eacute;ments
    mais dans l'ordre inverse, en pr&eacute;servant les cl&eacute;s si le param&egrave;tre
    <parameter>preserve_keys</parameter> vaut &true;.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_reverse</function></title>
     <programlisting role="php">
&lt;?php
  $input = array ("php", 4.0, array ("rouge", "vert"));
  $result = array_reverse ($input);
  $result_keyed = array_reverse ($input, TRUE);
?&gt;
     </programlisting>
    </example>
    Au final, <varname>$result</varname> et <varname>$result_keyed</varname>
    contiennent tous les deux <literal>array ("rouge", "vert"), 4.0, "php"</literal>,
    dans cet ordre. Mais <varname>$result_keyed[0]</varname> vaut toujours
    <literal>"php"</literal>.
    <note>
     <para>
      <function>array_reverse</function> a &eacute;t&eacute; ajout&eacute;e en
      PHP 4.0 Beta 3.
     </para>
    </note>
    <note>
     <para>
      Le second param&egrave;tre <parameter>preserve_keys</parameter> a &eacute;t&eacute;
      ajout&eacute; en PHP 4.0.3.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-reduce">
  <refnamediv>
   <refname>array_reduce</refname>
   <refpurpose>
    R&eacute;duit it&eacute;rativement un tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>array_reduce</methodname>
     <methodparam><type>array</type><parameter>input</parameter></methodparam>
     <methodparam><type>mixed</type><parameter>callback</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>initial</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_reduce</function> applique it&eacute;rativement
    la fonction <parameter>callback</parameter> aux &eacute;l&eacute;ments du
    tableau <parameter>input</parameter>, de mani&egrave;re &agrave; r&eacute;duire le
    tableau &agrave; une valeur simple. Si l'argument optionnel
    <parameter>intial</parameter> est disponible, il sera utilis&eacute; pour
    initialiser le processus, ou bien comme valeur finale si le
    tableau est vide.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_reduce</function></title>
     <programlisting role="php">
&lt;?php
  function rsum($v, $w) {
    $v += $w;
    return $v;
  }
  function rmul($v, $w) {
    $v *= $w;
    return $v;
  }
  $a = array(1, 2, 3, 4, 5);
  $x = array();
  $b = array_reduce($a, "rsum");
  $c = array_reduce($a, "rmul", 10);
  $d = array_reduce($x, "rsum", 1);
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Dans cet exemple, <varname>$b</varname> contiendra <literal>15</literal>,
    <varname>$c</varname> contiendra <literal>1200</literal> (= 1*2*3*4*5*10),
    et <varname>$d</varname> contiendra <literal>1</literal>.
   </para>
   <para>
    Voir aussi
    <function>array_filter</function> et
    <function>array_map</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-rand">
  <refnamediv>
   <refname>array_rand</refname>
   <refpurpose>
    Prend une ou plusieurs valeurs, au hasard dans un tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>array_rand</methodname>
     <methodparam><type>array</type><parameter>input</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>num_req</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_rand</function> est pratique lorsque vous voulez
    s&eacute;lectionner une ou plusieurs valeurs au hasard dans un tableau.
    Le param&egrave;tre <parameter>input</parameter> est un tableau, et
    <parameter>num_req</parameter> sp&eacute;ficie le nombre de valeurs que
    vous voulez obtenir (par d&eacute;faut, c'est 1).
   </para>
   <para>
    Si vous ne demandez qu'une entr&eacute;e, <function>array_rand</function>
    retourne l'index de la valeur. Sinon, elle retourne un tableau
    d'index. Cela vous permet de faire une s&eacute;lection au hasard de cl&eacute;s,
    ou bien de valeurs.
   </para>
   <para>
    N'oubliez pas d'appeler <function>srand</function> pour initialiser le
    g&eacute;n&eacute;rateur de nombres al&eacute;atoires.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_rand</function></title>
     <programlisting role="php">
&lt;?php
  srand ((double) microtime() * 10000000);
  $input = array ("Neo", "Morpheus", "Trinit&eacute;e", "Cypher", "Tank");
  $rand_keys = array_rand ($input, 2);
  print $input[$rand_keys[0]]."\n";
  print $input[$rand_keys[1]]."\n";
?&gt;
     </programlisting>
    </example>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-shift">
  <refnamediv>
   <refname>array_shift</refname>
   <refpurpose>
    D&eacute;pile un &eacute;l&eacute;ment au d&eacute;but d'un tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>array_shift</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_shift</function> extrait la premi&egrave;re valeur d'un
    tableau et la retourne, en raccourcissant le tableau d'un
    &eacute;l&eacute;ment, et en d&eacute;placant tous les
    &eacute;l&eacute;ments vers le bas.
    Si <parameter>array</parameter> est vide, ou n'est pas un tableau,
    <function>array_shift</function> retourne &null;.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_shift</function></title>
     <programlisting role="php">
&lt;?php
  $args = array("-v", "-f");
  $opt = array_shift($args);
?&gt;
     </programlisting>
    </example>
    Cet exemple aura pour r&eacute;sultat que $args ne contiendra plus que "-f",
    et $opt contient "-v".
   </para>
   <para>
    Voir aussi
    <function>array_unshift</function>,
    <function>array_push</function> et
    <function>array_pop</function>.
    <note>
     <para>
      <function>array_shift</function> a &eacute;t&eacute; ajout&eacute;e en PHP
      4.0.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-slice">
  <refnamediv>
   <refname>array_slice</refname>
   <refpurpose>Extrait une portion de tableau </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_slice</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
     <methodparam><type>int</type><parameter>offset</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>
      length
      </parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_slice</function> retourne une s&eacute;rie d'
    &eacute;l&eacute;ment du tableau <parameter>array</parameter> commen&ccedil;ant &agrave;
    l'offset <parameter>offset</parameter> et repr&eacute;sentant
    <parameter>length</parameter> &eacute;l&eacute;ments.
   </para>
   <para>
    Si <parameter>offset</parameter> est positif, la s&eacute;rie commencera
    &agrave; cet offset dans le tableau <parameter>array</parameter>. Si
    <parameter>offset</parameter> est n&eacute;gatif, cette s&eacute;rie
    commencera &agrave; l'offset <parameter>offset</parameter> mais en
    commen&ccedil;ant &agrave; la fin du tableau <parameter>array</parameter>.
   </para>
   <para>
    Si <parameter>length</parameter> est fourni et positif, alors la
    s&eacute;rie retourn&eacute;e aura autant d'&eacute;l&eacute;ments.
    Si <parameter>length</parameter> est fourni et n&eacute;gatif, alors la
    s&eacute;rie contiendra les &eacute;l&eacute;ments depuis l'offset
    <parameter>offset</parameter> jusqu'&agrave; <parameter>length</parameter>
    &eacute;l&eacute;ments en partant de la fin. Si
    <parameter>length</parameter> est omis, la s&eacute;quence lira tous les
    &eacute;l&eacute;ments du tableau, depuis l'<parameter>offset</parameter>
    pr&eacute;cis&eacute; jusqu'&agrave; la fin du tableau.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_slice</function></title>
     <programlisting role="php">
&lt;?php
  $input = array("a", "b", "c", "d", "e");
  $output = array_slice($input, 2);      // retourne "c", "d", et "e"
// les trois exemples suivants sont &eacute;quivalents
  $output = array_slice($input, 2, 2);  // retourne "c", "d"
  $output = array_slice($input, 2, -1);  // retourne "c", "d"
// Equivalent &agrave; :
  $offset = 2; $length = -1;
  $output = array_slice($input, 2, count($input) - $offset + $length);
// retourne "c", "d"
  $output = array_slice($input, -2, 1);  // retourne "d"
  $output = array_slice($input, 0, 3);   // retourne "a", "b", et "c"
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>array_splice</function>.
    <note>
     <para>
      <function>array_slice</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.0.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-splice">
  <refnamediv>
   <refname>array_splice</refname>
   <refpurpose>
    Efface et remplace une portion de tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_splice</methodname>
     <methodparam><type>array</type><parameter>input</parameter></methodparam>
     <methodparam><type>int</type><parameter>offset</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>length</parameter></methodparam>
     <methodparam choice="opt"><type>array</type><parameter>
      replacement
      </parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_splice</function> supprime les &eacute;l&eacute;ments
    d&eacute;sign&eacute;s par <parameter>offset</parameter> et
    <parameter>length</parameter> du tableau <parameter>input</parameter> et
    les remplace par les &eacute;l&eacute;ments du tableau
    <parameter>replacement</parameter>, si ce dernier est pr&eacute;sent.
   </para>
   <para>
    Si <parameter>offset</parameter> est positif, la s&eacute;rie commencera
    &agrave; cet offset dans le tableau  <parameter>input</parameter>.
    Si <parameter>offset</parameter> est n&eacute;gatif, cette s&eacute;rie
    commencera &agrave; l'offset <parameter>offset</parameter> mais en commen&ccedil;ant
    &agrave; la fin du tableau <parameter>input</parameter>.
   </para>
   <para>
    Si <parameter>length</parameter> est donn&eacute; et positif, alors la
    s&eacute;rie aura autant d'&eacute;l&eacute;ments. Si <parameter>length</parameter>
    est donn&eacute; et n&eacute;gatif, les &eacute;l&eacute;ments seront pris
    dans l'ordre inverse.
    Si <parameter>length</parameter> est omis, la s&eacute;quence lira tous les
    &eacute;l&eacute;ments du tableau, depuis l'offset <parameter>offset</parameter>
    jusqu'&agrave; la fin du tableau.
    Conseil : pour supprimer tous les &eacute;l&eacute;ments du tableau depuis
    <parameter>offset</parameter> jusqu'&agrave; la fin, m&ecirc;me si un tableau
    de remplacement <parameter>replacement</parameter> est sp&eacute;cifi&eacute;, utilisez
    count(<literal>count($input)</literal>) &agrave; la place de length.
   </para>
   <para>
    Si <parameter>replacement</parameter> est pr&eacute;cis&eacute;, alors les
    &eacute;l&eacute;ments supprim&eacute;s sont remplac&eacute;s par les
    &eacute;l&eacute;ments de ce tableau. Si l'<parameter>offset</parameter>
    et <parameter>length</parameter> sont tels que la taille du tableau ne change pas,
    alors les &eacute;l&eacute;ments du tableau de remplacement replacement sont
    ins&eacute;r&eacute;s &agrave; partir de l'offset <parameter>offset</parameter>.
   </para>
   <para>
    Conseil : si le tableau de remplacement ne contient qu'un seul
    &eacute;l&eacute;ment, il n'est pas obligatoire de forcer le type en
    tableau avec <function>array</function>, &agrave; moins que cette variable ne soit
    elle-m&ecirc;me un tableau.
   </para>
   <para>
    Les codes suivants sont &eacute;quivalents :
    <programlisting role="php">
&lt;?php
  array_push($input, $x, $y)     array_splice($input, count($input), 0, array($x, $y))
  array_pop($input)              array_splice($input, -1)
  array_shift($input)            array_splice($input, 0, 1)
  array_unshift($input, $x, $y)  array_splice($input, 0, 0, array($x, $y))
  $a[$x] = $y                    array_splice($input, $x, 1, $y)
?&gt;
    </programlisting>
   </para>
   <para>
    <function>array_splice</function> retourne le tableau des &eacute;l&eacute;ments
    supprim&eacute;s.
   </para>
   <para>
    <example>
     <title>Exemples avec <function>array_splice</function></title>
     <programlisting role="php">
&lt;?php
// cas simple
  $input = array("rouge", "vert", "bleu", "jaune");
  array_splice($input, 2);
// $input est array("rouge", "vert")
// nombre d'&eacute;l&eacute;ments n&eacute;gatif
  $input = array("rouge", "vert", "bleu", "jaune");
  array_splice($input, 1, -1);
// $input est array("rouge", "jaune")
// avec un &eacute;l&eacute;ment de remplacement
  $input = array("rouge", "vert", "bleu", "jaune");
  array_splice($input, 1, count($input), "orange");
// $input est array("rouge", "orange")
//  cas complexe
  $input = array("rouge", "vert", "bleu", "jaune");
  array_splice($input, -1, 1, array("noir", "marron"));
// $input est array("rouge", "vert",
//          "bleu", "noir", "marron")
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>array_slice</function>.
    <note>
     <para>
      <function>array_splice</function> a &eacute;t&eacute; ajout&eacute;e
      en PHP 4.0.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-sum">
  <refnamediv>
   <refname>array_sum</refname>
   <refpurpose>
    Calcule la somme des valeurs du tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>array_sum</methodname>
     <methodparam><type>array</type><parameter>arr</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_sum</function> retourne la somme des
    valeurs du tableau, sous forme d'un entier ou d'un
    nombre &agrave; virgule flottante.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>array_sum</function></title>
     <programlisting role="php">
&lt;?php
  $a = array(2,4,6,8);
  echo "somme(a) = ".array_sum($a)."\n";
// affiche : somme(a) = 20
  $b = array("a"=>1.2,"b"=>2.3,"c"=>3.4);
  echo "somme(b) = ".array_sum($b)."\n";
// affiche : somme(b) = 6.9
?&gt;
     </programlisting>
    </example>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-unique">
  <refnamediv>
   <refname>array_unique</refname>
   <refpurpose>D&eacute;doublonne un tableau</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_unique</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_unique</function> prend le tableau
    <parameter>array</parameter> et retourne un nouveau tableau,
    compl&egrave;tement d&eacute;doublonn&eacute;.
   </para>
    <note>
     <simpara>
      Deux &eacute;l&eacute;ments sont consid&eacute;r&eacute;s comme &eacute;gaux si et seulement si 
      <literal>(string) $elem1 === (string) $elem2</literal>. En clair :
      lorsque la repr&eacute;sentation en cha&icirc;ne de caract&egrave;res est identique.
      <!-- TODO: example of it... -->
     </simpara>
    </note>
    <warning>
     <simpara>
      Cette fonction &eacute;tait inutilisable en PHP 4.0.4!
      <!-- TODO: when exactly was this broken?... -->
     </simpara>
    </warning>
   <para>
    Notez que les cl&eacute;s sont pr&eacute;serv&eacute;es.
    <function>array_unique</function> conserve la cl&eacute; de la
    premi&egrave;re valeur rencontr&eacute;e, et ignore toutes les suivantes.
   </para>
   <para>
     <example>
      <title>Exemple avec <function>array_unique</function></title>
      <programlisting role="php">
&lt;?php
  $input = array ("a" =&gt; "vert", "rouge", "b" =&gt; "vert", "bleu", "rouge");
  $result = array_unique ($input);
  print_r($result);
// Cela va afficher :
//Array
//(
//    [a] => vert
//    [0] => rouge
//    [1] => bleu
//)
?&gt;
      </programlisting>
     </example>
    </para>
<!--
    <para>
     Notez aussi que <function>array_unique</function> tient compte du
     type de la valeur. Cela ne porte g&eacute;n&eacute;ralement pas &agrave;
     cons&eacute;quence, sauf si votre tableau contient des nombres, qui
     peuvent &ecirc;tre de diff&eacute;rents types. Cela conduit &agrave; des
     r&eacute;sultats d&eacute;routants.
    </para>
-->
    <para>
     <example>
      <title><function>array_unique</function> et les types de valeurs</title>
      <programlisting role="php">
&lt;?php
  $input = array(4,"3",3,"4",4,4);
  $result = array_unique($input);
  print_r($result);
// Cela va afficher :
//Array
//(
//  [0] => 3
//  [1] => 3
//  [2] => 4
//  [3] => 4
//)
?&gt;
      </programlisting>
     </example>
    </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-unshift">
  <refnamediv>
   <refname>array_unshift</refname>
   <refpurpose>
    Empile un ou plusieurs &eacute;l&eacute;ments au d&eacute;but d'un
    tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>array_unshift</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
     <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
     <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_unshift</function> ajoute les &eacute;l&eacute;ments pass&eacute;s
    en argument au d&eacute;but du tableau <parameter>array</parameter>. Notez que
    les &eacute;l&eacute;ments sont ajout&eacute;s comme un tout, et qu'ils restent
    dans le m&ecirc;me ordre.
   </para>
   <para>
    <function>array_unshift</function> retourne le nouveau nombre
    d'&eacute;l&eacute;ments du tableau
    <parameter>array</parameter>.
   </para>
   <para>
    <example>
     <title>Exemples avec <function>array_unshift</function></title>
     <programlisting role="php">
&lt;?php
  $queue = array("p1", "p3");
  array_unshift($queue, "p4", "p5", "p6");
?&gt;
     </programlisting>
    </example>
    Le r&eacute;sultat de cet exemple est que $queue aura 5
    &eacute;l&eacute;ments, &agrave; savoir: "p4", "p5", "p6", "p1", et "p3".
   </para>
   <para>
    Voir aussi
    <function>array_shift</function>,
    <function>array_push</function>, et
    <function>array_pop</function>.
    <note>
     <para>
      <function>array_unshift</function> a &eacute;t&eacute; ajout&eacute;e en
      PHP 4.0.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-values">
  <refnamediv>
   <refname>array_values</refname>
   <refpurpose>Retourne les valeurs d'un tableau </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>array_values</methodname>
     <methodparam><type>array</type><parameter>input</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_values</function>retourne les valeurs du tableau
    <parameter>input</parameter>.
   </para>
   <para>
    <example>
     <title>Exemples avec <function>array_values</function></title>
     <programlisting role="php">
&lt;?php
  $array = array("taille" =&gt; "XL", "couleur" =&gt; "or");
  array_values($array);    // // retourne array("XL", "or")
?&gt;
     </programlisting>
    </example>
    <note>
     <para>
      <function>array_values</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.
      Ci-dessous, voici une impl&eacute;mentation pour ceux qui utilisent
      toujours PHP 3.
      <example>
       <title>
        Impl&eacute;mentation de <function>array_values</function> pour les utilisateurs
        PHP 3
       </title>
       <programlisting role="php">
&lt;?php
  function array_values($arr){
    $t = array();
    while (list($k, $v) = each($arr)){
        $t[] = $v;
    }
    return $t;
  }
?&gt;
       </programlisting>
      </example>
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-walk">
  <refnamediv>
   <refname>array_walk</refname>
   <refpurpose>
    Ex&eacute;cute une fonction sur chacun des membres d'un tableau.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>array_walk</methodname>
     <methodparam><type>array</type><parameter>arr</parameter></methodparam>
     <methodparam><type>string</type><parameter>func</parameter></methodparam>
     <methodparam><type>mixed</type><parameter>userdata</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>array_walk</function> ex&eacute;cute la fonction <parameter>func</parameter>
    avec chaque &eacute;l&eacute;ment du tableau <parameter>arr</parameter>. Les
    &eacute;l&eacute;ments sont pass&eacute;s en tant que premier argument de la
    fonction <parameter>func</parameter>. <parameter>func</parameter> doit &ecirc;tre
    une fonction d&eacute;finie par l'utilisateur, et non pas une fonction native
    PHP. Vous ne pouvez pas utiliser <function>array_walk</function> directement
    avec <function>str2lower</function>, il faut absolument passer par une fonction utilisateur.
   </simpara>
   <simpara>
    Si <parameter>func</parameter> a besoin de plus d'un argument, une alerte
    sera g&eacute;n&eacute;r&eacute;e pour chaque appel de <parameter>func</parameter>.
    Ces alertes sont supprim&eacute;es en ajoutant le suffixe '&#64;' avant l'appel de
    <function>array_walk</function> ou simplement en utilisant
    <function>error_reporting</function>.
   </simpara>
   <note>
    <para>
     Si <parameter>func</parameter> doit travailler avec les v&eacute;ritables
     valeurs du tableau, sp&eacute;cifiez que le premier param&egrave;tre de
     <parameter>func</parameter> doit &ecirc;tre pass&eacute; par
     r&eacute;f&eacute;rence. Alors, les &eacute;l&eacute;ments seront directement
     modifi&eacute;s dans le tableau.
    </para>
   </note>
   <note>
    <para>
     Passer les cl&eacute;s et <parameter>userdata</parameter> &agrave;
     <parameter>func</parameter> a &eacute;t&eacute; ajout&eacute; en PHP 4.0.
    </para>
    <para>
     En PHP 4, <function>reset</function> doit &ecirc;tre appel&eacute; si
     n&eacute;cessaire, car <function>array_walk</function> ne r&eacute;initialise pas
     automatiquement le tableau.
    </para>
   </note>
   <para>
    <example>
     <title>Exemple avec <function>array_walk</function></title>
     <programlisting role="php">
&lt;?php
  $fruits = array ("d"=&gt;"citron", "a"=&gt;"orange", "b"=&gt;"banane", "c"=&gt;"pomme");
  function test_alter (&amp;$item1, $key, $prefix) {
    $item1 = "$prefix: $item1";
  }
  function test_print ($item2, $key) {
    echo "$key. $item2&lt;br&gt;\n";
  }
  array_walk ($fruits, 'test_print');
  reset ($fruits);
  array_walk ($fruits, 'test_alter', 'fruit');
  reset ($fruits);
  array_walk ($fruits, 'test_print');
?&gt;
     </programlisting>
    </example>
   </para>
   <simpara>
    Voir aussi
    <function>each</function> et
    <function>list</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.arsort">
  <refnamediv>
   <refname>arsort</refname>
   <refpurpose>
    Trie un tableau en ordre inverse
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>arsort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>arsort</function> trie un tableau de telle mani&egrave;re
    que la corr&eacute;lation entre les index et les valeurs soit
    conserv&eacute;e. L'usage principal est lors de tri de tableaux
    associatifs o&ugrave; l'ordre des &eacute;l&eacute;ments est important.
    <example>
     <title>Exemple avec <function>arsort</function></title>
     <programlisting role="php">
&lt;?php
  $fruits = array("d"=&gt;"papaye","a"=&gt;"orange","b"=&gt;"banane","c"=&gt;"ananas");
  arsort ($fruits);
  for (reset ($fruits); $key = key ($fruits); next ($fruits)) {
    echo "fruits[$key] = ".$fruits[$key]."\n";
  }
?&gt;
     </programlisting>
    </example>
    Cet exemple va afficher:
    <computeroutput>
    fruits[d] = papaye
    fruits[a] = orange
    fruits[b] = banane
    fruits[c] = ananas
    </computeroutput>
    Les fruits ont &eacute;t&eacute; tri&eacute;s en ordre alphab&eacute;tique
    inverse, et leurs index respectifs ont &eacute;t&eacute; conserv&eacute;s.
   </para>
   <para>
    Voir aussi
    <function>array-multisort</function>,
    <function>asort</function>,
    <function>krsort</function>,
    <function>ksort</function>,
    <function>natsort</function>,
    <function>natcasesort</function>,
    <function>rsort</function>,
    <function>sort</function>,
    <function>uasort</function>,
    <function>uksort</function> et
    <function>usort</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.asort">
  <refnamediv>
   <refname>asort</refname>
   <refpurpose>Trie un tableau en ordre</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>asort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>asort</function> trie un tableau de telle mani&egrave;re que
    la corr&eacute;lation entre les index et les valeurs soit conserv&eacute;e.
    L'usage principal est lors de tri de tableaux associatifs o&ugrave; l'ordre
    des &eacute;l&eacute;ments est important.
    <example>
     <title>Exemple avec <function>asort</function></title>
     <programlisting role="php">
&lt;?php
  $fruits = array(  "d"=&gt;"papaye",
                    "a"=&gt;"orange",
                    "b"=&gt;"banane",
                    "c"=&gt;"ananas");
  asort($fruits);
  for(reset($fruits); $key = key($fruits); next($fruits)) {
    echo "fruits[$key] = ".$fruits[$key]."\n";
  }
?&gt;
     </programlisting>
    </example>
    Cet exemple va afficher:
    <computeroutput>
    fruits[c] = ananas
    fruits[b] = banane
    fruits[a] = orange
    fruits[d] = papaye
    </computeroutput>
    Les fruits ont &eacute;t&eacute; tri&eacute;s par ordre alphab&eacute;tique,
    et leurs index respectifs ont &eacute;t&eacute; conserv&eacute;s.
   </para>
   <para>
    Voir aussi
    <function>array-multisort</function>,
    <function>arsort</function>,
    <function>krsort</function>,
    <function>ksort</function>,
    <function>natsort</function>,
    <function>natcasesort</function>,
    <function>rsort</function>,
    <function>sort</function>,
    <function>uasort</function>,
    <function>uksort</function> et
    <function>usort</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.compact">
  <refnamediv>
   <refname>compact</refname>
   <refpurpose>
    Cr&eacute;e un tableau contenant les variables et leur valeur
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>compact</methodname>
     <methodparam><type>string|array</type><parameter>varname</parameter></methodparam>
     <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>compact</function> accepte diff&eacute;rents param&egrave;tres. Les
    param&egrave;tres peuvent &ecirc;tre des variables contenant des cha&icirc;nes,
    ou un tableau de cha&icirc;nes, qui peut contenir d'autres tableaux de noms, que
    <function>compact</function> traitera r&eacute;cursivement.
   </para>
   <para>
    Pour chacun des arguments, <function>compact</function> recherche une variable
    avec une variable de m&ecirc;me nom dans la table courante des symboles, et
    l'ajoute dans le tableau, de mani&egrave;re &agrave; avoir la relation nom =&gt;
    'valeur de variable'. En bref, c'est le contraire de la fonction
    <function>extract</function>. <function>compact</function> retourne
    le tableau ainsi cr&eacute;&eacute;.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>compact</function></title>
     <programlisting role="php">
&lt;?php
  $ville = "San Francisco";
  $etat = "CA";
  $evenement = "SIGGRAPH";
  $location_vars = array("ville", "etat");
  $result = compact("evenement", $location_vars);
?&gt;
     </programlisting>
     <para>
      Apr&egrave;s cette op&eacute;ration, $result sera le tableau suivant :
      array(("evenement" =&gt; "SIGGRAPH", "ville" =&gt; "San Francisco", "etat" =&gt; "CA").
     </para>
    </example>
   </para>
   <para>
    Voir aussi
    <function>extract</function>.
    <note>
     <para>
      <function>compact</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.0.
     </para>
    </note>
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.count">
  <refnamediv>
   <refname>count</refname>
   <refpurpose>Compte le nombre d'&eacute;l&eacute;ments d'un tableau </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>count</methodname>
     <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>count</function> retourne le nombre d'&eacute;l&eacute;ments dans
    <parameter>var</parameter>, qui est g&eacute;n&eacute;ralement un tableau
    (et tout le reste n'aura qu'un &eacute;l&eacute;ment).
   </para>
   <para>
    If <parameter>var</parameter> n'est pas un tableau, <literal>1</literal>
    sera retourn&eacute; (exception : <literal>count(&null;)</literal> &eacute;gale 
    <literal>0</literal>).
   </para>
   <para>
    <warning>
    <para>
     <function>count</function> peut retourner 0 pour une
     variable qui n'a pas &eacute;t&eacute; affect&eacute;e, ou pour un tableau
     vide. Utilisez plut&ocirc;t <function>isset</function>
     pour tester si la variable existe.
    </para>
    </warning>
   </para>
   <para>
    <example>
     <title>Exemple avec <function>count</function></title>
     <programlisting role="php">
&lt;?php
  $a[0] = 1;
  $a[1] = 3;
  $a[2] = 5;
  $result = count ($a);
  //$result == 3
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>sizeof</function>,
    <function>isset</function> et
    <function>is_array</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.current">
  <refnamediv>
   <refname>current</refname>
   <refpurpose>Transforme une variable en tableau</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>current</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    Chaque tableau entretient un pointeur interne, qui est initialis&eacute;
    lorsque le premier &eacute;l&eacute;ment est ins&eacute;r&eacute; dans le tableau.
   </para>
   <para>
    <function>current</function> ne fait que retourner
    l'&eacute;l&eacute;ment courant point&eacute; par le pointeur interne du
    tableau <parameter>array</parameter>.
    <function>current</function> ne d&eacute;place pas le pointeur.
    Si le pointeur est au-del&agrave; du dernier &eacute;l&eacute;ment de la liste,
    <function>current</function> retourne &false;.
    <warning>
    <para>
     Si le tableau des &eacute;l&eacute;ments vides ou des z&eacute;ros (0 ou "",
     la cha&icirc;ne vide) alors <function>current</function> retournera
     &false; pour ces &eacute;l&eacute;ments. Il est donc
     impossible de d&eacute;terminer si vous &ecirc;tes r&eacute;ellement
     &agrave; la fin de la liste en utilisant la fonction
     <function>current</function>.  Pour passer en revue proprement un
     tableau qui peut contenir des &eacute;l&eacute;ments vides ou des z&eacute;ros,
     utilisez la fonction <function>each</function>.
    </para>
    </warning>
   </para>
   <para>
    Voir aussi
    <function>end</function>,
    <function>next</function>,
    <function>prev</function> et
    <function>reset</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.each">
  <refnamediv>
   <refname>each</refname>
   <refpurpose>
    Retourne chaque paire cl&eacute;/valeur d'un tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>each</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>each</function> retourne la paire (cl&eacute;/valeur) courante
    du tableau <parameter>array</parameter> et avance le pointeur de tableau.
    Cette paire est retourn&eacute;e dans un tableau de 4 &eacute;l&eacute;ments,
    avec les cl&eacute;s  <emphasis>0</emphasis>, <emphasis>1</emphasis>,
    <emphasis>key</emphasis>, et <emphasis>value</emphasis>. Les
    &eacute;l&eacute;ments <emphasis>0</emphasis> et <emphasis>key</emphasis>
    contiennent le nom de la cl&eacute; et, et <emphasis>1</emphasis> et
    <emphasis>value</emphasis> contiennent la valeur.
   </para>
   <para>
    Si le pointeur interne de fichier est au-del&agrave; de la fin du tableau,
    <function>each</function> retourne &false;.
   </para>
   <para>
    <example>
     <title>Exemples avec <function>each</function></title>
     <programlisting role="php">
&lt;?php
  $foo = array("bob", "fred", "jussi", "jouni", "egon", "marliese");
  $bar = each($foo);
?&gt;
     </programlisting>
     <para>
      <literal>$bar</literal> contient maintenant les paires suivantes:
      <itemizedlist spacing="compact">
       <listitem><simpara>0 =&gt; 0</simpara></listitem>
       <listitem><simpara>1 =&gt; 'bob'</simpara></listitem>
       <listitem><simpara>key =&gt; 0</simpara></listitem>
       <listitem><simpara>value =&gt; 'bob'</simpara></listitem>
      </itemizedlist>
      <programlisting role="php">
&lt;?php
  $foo = array ("Robert" =&gt; "Bob", "Seppo" =&gt; "Sepi");
  $bar = each ($foo);
?&gt;
      </programlisting>
     </para>
     <para>
      <literal>$bar</literal> contient maintenant les paires suivantes:
      <itemizedlist spacing="compact">
       <listitem><simpara>0 =&gt; 'Robert'</simpara></listitem>
       <listitem><simpara>1 =&gt; 'Bob'</simpara></listitem>
       <listitem><simpara>key =&gt; 'Robert'</simpara></listitem>
       <listitem><simpara>value =&gt; 'Bob'</simpara></listitem>
      </itemizedlist>
     </para>
    </example>
   </para>
   <para>
    <function>each</function> est utilis&eacute; conjointement avec
    <function>list</function> pour &eacute;tudier tous les &eacute;l&eacute;ments
    d'un tableau; par exemple, $HTTP_POST_VARS:
    <example>
     <title>
      Affichage de $HTTP_POST_VARS avec <function>each</function>
     </title>
     <programlisting role="php">
&lt;?php
  echo "Valeurs transmises par la m&eacute;thode POST:&lt;br&gt;";
  reset ($HTTP_POST_VARS);
  while (list ($key, $val) = each ($HTTP_POST_VARS)) {
    echo "$key =&gt; $val&lt;br&gt;";
  }
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Apr&egrave;s chaque <function>each</function>, le pointeur de tableau est
    d&eacute;plac&eacute; au dernier &eacute;l&eacute;ment, ou sur le dernier
    &eacute;l&eacute;ment, lorsqu'on arrive &agrave; la fin.
   </para>
   <para>
    Voir aussi
    <function>key</function>,
    <function>list</function>,
    <function>current</function>,
    <function>reset</function>,
    <function>next</function> et
    <function>prev</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.end">
  <refnamediv>
   <refname>end</refname>
   <refpurpose>
    Positionne le pointeur de tableau en fin de tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <methodname>end</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>end</function> d&eacute;place le pointeur interne du tableau
    <parameter>array</parameter> jusqu'au dernier &eacute;l&eacute;ment.
   </para>
   <para>
    Voir aussi
    <function>current</function>,
    <function>each</function>,
    <function>end</function>,
    <function>next</function> et
    <function>reset</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.extract">
  <refnamediv>
   <refname>extract</refname>
   <refpurpose>
    Importe les variables dans la table des symboles
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>extract</methodname>
     <methodparam><type>array</type><parameter>var_array</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>extract_type</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>prefix</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>extract</function> sert &agrave; exporter un tableau vers
    la table des symboles. Elle prend un tableau associatif
    <parameter>var_array</parameter>, cr&eacute;e les variables dont les
    noms sont les index de ce tableau, et leur affecte la valeur associ&eacute;e.
    Pour chaque paire cl&eacute;/valeur, <function>extract</function> cr&eacute;e
    une variable, avec les param&egrave;tres <parameter>extract_type</parameter>
    et <parameter>prefix</parameter>.
   </para>
   <note>
    <para>
     Depuis la version 4.0.5, <function>extract</function> retourne le nombre de
     variables extraites.
    </para>
   </note>
   <para>
    <function>extract</function> v&eacute;rifie l'existence de la variable avant
    de la cr&eacute;er. Le traitement des collisions est
    d&eacute;termin&eacute; par <parameter>extract_type</parameter>.
    Ce param&egrave;tre peut prendre une des valeurs suivantes :
    <variablelist>
    <varlistentry>
    <term>EXTR_OVERWRITE</term>
    <listitem>
     <simpara>
      Lors d'une collision, r&eacute;&eacute;crire la variable existante.
     </simpara>
    </listitem>
    </varlistentry>
    <varlistentry>
    <term>EXTR_SKIP</term>
    <listitem>
     <simpara>
      Lors d'une collision, ne pas r&eacute;&eacute;crire la variable existante.
     </simpara>
    </listitem>
    </varlistentry>
    <varlistentry>
    <term>EXTR_PREFIX_SAME</term>
    <listitem>
     <simpara>
      Lors d'une collision, ajouter le pr&eacute;fixe <parameter>prefix</parameter>,
      et cr&eacute;er une nouvelle variable.
     </simpara>
    </listitem>
    </varlistentry>
    <varlistentry>
    <term>EXTR_PREFIX_ALL</term>
    <listitem>
     <simpara>
      Ajouter le pr&eacute;fixe <parameter>prefix</parameter>, et cr&eacute;er
      une nouvelle variable.
     </simpara>
    </listitem>
    </varlistentry>
    <varlistentry>
    <term>EXTR_PREFIX_INVALID</term>
    <listitem>
     <simpara>
      Pr&eacute;fixer uniquement les variables aux noms invalides ou num&eacute;riques
      avec le pr&eacute;fixe <parameter>prefix</parameter>. Ceci a
      &eacute;t&eacute; ajout&eacute; en PHP 4.0.5.
     </simpara>
    </listitem>
    </varlistentry>
    </variablelist>
   </para>
   <para>
    Si <parameter>extract_type</parameter> est omis, <function>extract</function>
    utilise EXTR_OVERWRITE par d&eacute;faut.
   </para>
   <para>
    Notez que <parameter>prefix</parameter> n'est n&eacute;cessaire que pour
    les valeurs de <parameter>extract_type</parameter> suivantes :
    EXTR_PREFIX_SAME, EXTR_PREFIX_ALL ou EXTR_PREFIX_INVALID. Le r&eacute;sultat
    pr&eacute;fix&eacute; n'est pas un nom de variable valide,
    il ne sera pas import&eacute; dans la table des symboles.
   </para>
   <para>
    <function>extract</function> retourne le nombre de variables r&eacute;ellement
    import&eacute;es dans la table des symboles.
   </para>
   <para>
    Une utilisation possible de la fonction <function>extract</function> est l'exportation
    vers la table des symboles de tableaux de variables retourn&eacute;s
    par <function>wddx_deserialize</function>.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>extract</function></title>
     <programlisting role="php">
&lt;?php
/* Supposons que $var_array est un tableau retourn&eacute; par
   <function>wddx_deserialize</function> */
  $taille = "grand";
  $var_array = array("couleur" =&gt; "bleu",
                     "taille"  =&gt; "moyen",
                     "forme" =&gt; "sphere");
  extract($var_array, EXTR_PREFIX_SAME, "wddx");
  print "$couleur, $taille, $forme, $wddx_taille\n";
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    L'exemple ci-dessus va afficher
    <computeroutput>
    bleu, large, sphere, moyen
    </computeroutput>
   </para>
   <para>
    La variable $taille n'a pas &eacute;t&eacute; r&eacute;&eacute;crite, car on
    avait sp&eacute;cifi&eacute; le param&egrave;tre EXTR_PREFIX_SAME, qui a permis
    la cr&eacute;ation $wddx_size. Si EXTR_SKIP avait &eacute;t&eacute;
    utilis&eacute;, alors $wddx_size n'aurait pas &eacute;t&eacute;
    cr&eacute;&eacute;. Avec EXTR_OVERWRITE, $taille aurait pris la valeur "moyen",
    et avec EXTR_PREFIX_ALL, les variables cr&eacute;&eacute;es seraient
    $wddx_couleur, $wddx_taille, et $wddx_forme.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.in-array">
  <refnamediv>
   <refname>in_array</refname>
   <refpurpose>
    Indique si une valeur appartient &agrave; un tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>boolean</type><methodname>in_array</methodname>
     <methodparam><type>mixed</type><parameter>needle</parameter></methodparam>
     <methodparam><type>array</type><parameter>haystack</parameter></methodparam>
     <methodparam choice="opt"><type>boolean</type><parameter>strict</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>in_array</function> recherche <parameter>needle</parameter> dans
    <parameter>haystack</parameter> et retourne &true;
    s'il s'y trouve, ou &false; sinon.
   </para>
   <para>
    Le troisi&egrave;me param&egrave;tre <parameter>strict</parameter> est
    optionnel. S'il vaut &true; alors <function>in_array</function>
    v&eacute;rifiera aussi que le types du param&egrave;tre <parameter>needle</parameter>
    correspond &agrave; la valeur trouv&eacute;e dans <parameter>haystack</parameter>.
   </para>
   <para>
    <example>
     <title>Exemple avec <function>in_array</function></title>
     <programlisting role="php">
&lt;?php
  $os = array("Mac", "NT", "Irix", "Linux");
  if (in_array("Irix", $os))
       print "Irix trouve";
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    <example>
     <title>
      <function>in_array</function> avec le param&egrave;tre <parameter>strict</parameter>
     </title>
     <programlisting role="php">
&lt;?php
  $a = array('1.10', 12.4, 1.13);
  if (in_array('12.4', $a, <literal>TRUE</literal>))
    echo &quot;'12.4' trouv&eacute; avec une recherche stricte\n&quot;;
  if (in_array(1.13, $a, <literal>TRUE</literal>))
    echo &quot;1.13 trouv&eacute; avec une recherche stricte\n&quot;;
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    L'affichage sera :
   </para>
   <informalexample>
    <screen>
    1.13 trouv&eacute; avec une recherche stricte
    </screen>
   </informalexample>
   <note>
    <para>
     <function>in_array</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.0.
    </para>
   </note>
   <para>
    Voir aussi
    <function>array_search</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.array-search">
  <refnamediv>
   <refname>array_search</refname>
   <refpurpose>
    Recherche dans un tableau la cl&eacute; associ&eacute;e &agrave; une valeur
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>array_search</methodname>
     <methodparam><type>mixed</type><parameter>needle</parameter></methodparam>
     <methodparam><type>array</type><parameter>haystack</parameter></methodparam>
     <methodparam><type>boolean</type><parameter>strict</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>array_search</function> recherche <parameter>needle</parameter>
    dans <parameter>haystack</parameter> et retourne la cl&eacute; associ&eacute;e s'il
    la trouve, ou &false; sinon.
   </para>
   <para>
    Si le troisi&egrave;me param&egrave;tre <parameter>strict</parameter> vaut
    &true;, alors <function>array_search</function>
    s'assurera aussi que le type de <parameter>needle</parameter>
    est le m&ecirc;me que celui de la valeur trouv&eacute;e dans <parameter>haystack</parameter>.
   </para>
   <para>
    Voir aussi
    <function>in_array</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.key">
  <refnamediv>
   <refname>key</refname>
   <refpurpose>Retourne une cl&eacute; d'un tableau associatif</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>key</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>key</function> retourne l'index de la cl&eacute; courante dans un
    tableau.
   </para>
   <para>
    Voir aussi
    <function>current</function> et
    <function>next</function>
   </para>
  </refsect1>
 </refentry>
  <!-- (temporarily?) undocumented
  <refentry id="function.key-exists">
   <refnamediv>
    <refname>key_exists</refname>
    <refpurpose>V&eacute;rifie si une cl&eacute; &eacute;xiste dans un tableau</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>bool</type><methodname>key_exists</methodname>
      <methodparam><type>mixed</type><parameter>key</parameter></methodparam>
      <methodparam><type>array</type><parameter>search</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>key_exists</function> retourne &true; s'il existe une
     cl&eacute; du nom de <parameter>key</parameter> dans le tableau 
     <parameter>search</parameter>. <parameter>key</parameter> 
     peut &ecirc;tre n'importe quelle valeur valide d'index
     de tableau.
    </para>
    <para>
     <example>
      <title>Exemple avec <function>key_exists</function></title>
      <programlisting role="php">
&lt;?php
$search_array = array("premier" => 1, "second" => 4);
if (key_exists("premier", $search_array)) {
    echo "L'&eacute;l&eacute;ment 'premier' existe dans le tableau";
}
?&gt;
      </programlisting>
     </example>
    </para>
    <para>
     See also <function>isset</function>.
    </para>
   </refsect1>
  </refentry>
  -->
 <refentry id="function.krsort">
  <refnamediv>
   <refname>krsort</refname>
   <refpurpose>
    Trie un tableau en sens inverse et suivant les cl&eacute;s
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>krsort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>krsort</function> trie un tableau en ordre inverse et suivant les
    cl&eacute;s, en maintenant la correspondance entre les cl&eacute;s et les
    valeurs. Cette fonction est pratique pour les tableaux associatifs.
    <example>
     <title>Exemple avec <function>krsort</function></title>
     <programlisting role="php">
&lt;?php
  $fruits = array("d"=&gt;"papaye","a"=&gt;"orange","b"=&gt;"banane","c"=&gt;"ananas");
  ksort($fruits);
  for(reset($fruits); $key = key($fruits); next($fruits)) {
    echo "fruits[$key] = ".$fruits[$key]."\n";
  }
?&gt;
     </programlisting>
    </example>
    Cet exemple va afficher :
    <computeroutput>
    fruits[d] = citron
    fruits[c] = ananas
    fruits[b] = banane
    fruits[a] = orange
    </computeroutput>
   </para>
   <simpara>
    Voir aussi
    <function>array-multisort</function>,
    <function>arsort</function>,
    <function>asort</function>,
    <function>ksort</function>,
    <function>natsort</function>,
    <function>natcasesort</function>,
    <function>rsort</function>,
    <function>sort</function>,
    <function>uasort</function>,
    <function>uksort</function> et
    <function>usort</function>.
   </simpara>
  </refsect1>
 </refentry>
 <refentry id="function.ksort">
  <refnamediv>
   <refname>ksort</refname>
   <refpurpose>Trie un tableau suivant les cl&eacute;s</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>ksort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>ksort</function> trie un tableau suivant les
    cl&eacute;s, en maintenant la correspondance entre les
    cl&eacute;s et les valeurs. Cette fonction est pratique
    pour les tableaux associatifs.
    <example>
     <title>Exemple avec <function>ksort</function></title>
     <programlisting role="php">
&lt;?php
  $fruits = array("d"=&gt;"papaye","a"=&gt;"orange","b"=&gt;"banane","c"=&gt;"ananas");
  ksort($fruits);
  reset($fruits);
  while (list ($key, $val) = each ($fruits)) {
    echo "$key =&gt; $val\n";
  }
?&gt;
     </programlisting>
    </example>
    Cet exemple va afficher :
    <computeroutput>
    fruits[a] = orange
    fruits[b] = banane
    fruits[c] = ananas
    fruits[d] = citron
    </computeroutput>
   </para>
   <para>
    Vous pouvez modifier le comportement du tri avec les
    options <parameter>sort_flags</parameter>. Pour plus de
    d&eacute;tails, voyez <function>sort</function>.
   </para>
   <simpara>
    Voir aussi
    <function>array-multisort</function>,
    <function>arsort</function>,
    <function>asort</function>,
    <function>krsort</function>,
    <function>natsort</function>,
    <function>natcasesort</function>,
    <function>rsort</function>,
    <function>sort</function>,
    <function>uasort</function>,
    <function>uksort</function> et
    <function>usort</function>.
   </simpara>
   <note>
    <para>
     Le second param&egrave;tre a &eacute;t&eacute; ajout&eacute; en PHP 4.0.
    </para>
   </note>
  </refsect1>
 </refentry>
 <refentry id="function.list">
  <refnamediv>
   <refname>list</refname>
   <refpurpose>
    Transforme une liste de variables en tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>list</methodname>
     <void/>
    </methodsynopsis>
   <para>
    Tout comme <function>array</function>, <function>list</function> n'est pas une
    v&eacute;ritable fonction, mais une construction syntaxique,
    qui permet d'assigner une s&eacute;rie de variables en une
    seule ligne.
    <example>
     <title>Exemple avec <function>list</function></title>
     <programlisting role="php">
&lt;?php
&lt;table&gt;
 &lt;tr&gt;
  &lt;th&gt;Nom de l'employ&eacute;&lt;/th&gt;
  &lt;th&gt;Salaire&lt;/th&gt;
 &lt;/tr&gt;
&lt;?php
  $result = mysql_query($conn, "SELECT id, name, salary FROM employees");
  while (list($id, $name, $salary) = mysql_fetch_row ($result)) {
    print (" &lt;tr&gt;\n".
           "  &lt;td&gt;&lt;a href=\"info.php3?id=$id\"&gt;$name&lt;/a&gt;&lt;/td&gt;\n".
           "  &lt;td&gt;$salaire&lt;/td&gt;\n".
           " &lt;/tr&gt;\n");
  }
?&gt;
&lt;/table&gt;
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>each</function> et
    <function>array</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.natsort">
  <refnamediv>
   <refname>natsort</refname>
   <refpurpose>
    Tri d'un tableau avec l'algorithme &agrave; "ordre naturel"
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>natsort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>natsort</function> impl&eacute;mente un algorithme
    de tri 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 tri de
    cha&icirc;nes (comme lorsqu'on utilise <function>sort</function>)
    est illustr&eacute; ci-dessous :
   </para>
   <para>
    <example>
     <title>Exemple avec <function>natsort</function></title>
     <programlisting role="php">
&lt;?php
  $array1 = $array2 = array ("img12.png","img10.png","img2.png","img1.png");
  sort($array1);
  echo "Tri Standard\n";
  print_r($array1);
  natsort($array2);
  echo "\nTri par Ordre Naturel\n";
  print_r($array2);
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    L'exemple ci-dessous g&eacute;n&egrave;re l'affichage suivant :
   </para>
   <para>
    <informalexample>
     <programlisting>
Tri Standard
Array
(
    [0] =&gt; img1.png
    [1] =&gt; img10.png
    [2] =&gt; img12.png
    [3] =&gt; img2.png
)
Tri par Ordre Naturel
Array
(
    [3] =&gt; img1.png
    [2] =&gt; img2.png
    [1] =&gt; img10.png
    [0] =&gt; img12.png
)
?&gt;
     </programlisting>
    </informalexample>
    Pour plus de d&eacute;tails, rendez-vous sur le site de Martin Pool
    <ulink url="&url.strnatcmp;">Natural Order String Comparison</ulink>.
   </para>
   <para>
    Voir aussi
    <function>array-multisort</function>,
    <function>arsort</function>,
    <function>asort</function>,
    <function>krsort</function>,
    <function>ksort</function>,
    <function>natsort</function>,
    <function>natcasesort</function>,
    <function>rsort</function>,
    <function>sort</function>,
    <function>uasort</function>,
    <function>uksort</function>,
    <function>usort</function>,
    <function>strnatcmp</function> et
    <function>strnatcasecmp</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.natcasesort">
  <refnamediv>
   <refname>natcasesort</refname>
   <refpurpose>
    Tri d'un tableau avec l'algorithme &agrave; "ordre naturel" insensible &agrave; la casse
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>natcasesort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>natcasesort</function> impl&eacute;mente un algorithme
    de tri 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".
   </para>
   <para>
    <function>natcasesort</function> est la version insensible &agrave; la
    casse de <function>natsort</function>.  Voir aussi
    <function>natsort</function> pour un exemple illustr&eacute;.
   </para>
   <para>
    Pour plus de d&eacute;tails, rendez-vous sur le site de :
    Martin Pool's
    <ulink url="&url.strnatcmp;">Natural Order String Comparison</ulink>.
   </para>
   <para>
    Voir aussi
    <function>array-multisort</function>,
    <function>arsort</function>,
    <function>asort</function>,
    <function>krsort</function>,
    <function>ksort</function>,
    <function>natsort</function>,
    <function>rsort</function>,
    <function>sort</function>,
    <function>uasort</function>,
    <function>uksort</function>,
    <function>usort</function>,
    <function>strnatcmp</function> et
    <function>strnatcasecmp</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.next">
  <refnamediv>
   <refname>next</refname>
   <refpurpose>
    Avance le pointeur interne d'un tableau
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>next</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>next</function> retourne l'&eacute;l&eacute;ment suivant du tableau,
    ou &false; s'il n'y a plus d'&eacute;l&eacute;ments. Le pointeur de interne de
    tableau est avanc&eacute; d'un &eacute;l&eacute;ment.
   </para>
   <para>
    <function>next</function> se comporte comme
    <function>current</function>, mais avec une diff&eacute;rence : il avance le
    pointeur interne de tableau d'un &eacute;l&eacute;ment avant de retourner la
    valeur qu'il pointe. Lorsque le pointeur d&eacute;passe le dernier
    &eacute;l&eacute;ment, <function>next</function> retourne &false;.
    <warning>
    <para>
     Si le tableau contient des &eacute;l&eacute;ments vides ou des z&eacute;ros,
     <function>next</function> retournera &false; pour ces &eacute;l&eacute;ments.
     Pour passer proprement en revue un tableau, il faut utiliser
     <function>each</function>.
    </para>
    </warning>
   </para>
   <para>
    Voir aussi
    <function>current</function>,
    <function>end</function>,
    <function>prev</function> et
    <function>reset</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.pos">
  <refnamediv>
   <refname>pos</refname>
   <refpurpose>Retourne l'&eacute;l&eacute;ment courant d'un tableau </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>pos</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <simpara>
    <function>pos</function> est une fonction alias de <function>current</function>.
   </simpara>
   <para>
    Voir aussi
    <function>end</function>,
    <function>next</function>,
    <function>prev</function> et
    <function>reset</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.prev">
  <refnamediv>
   <refname>prev</refname>
   <refpurpose>Recule le pointeur courant de tableau </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>prev</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>prev</function> repositionne le pointeur interne de tableau &agrave;
    la derni&egrave;re place qu'il occupait, ou bien retourne &false; s'il
    ne reste plus d'&eacute;l&eacute;ments.
    <warning>
    <para>
     Si le tableau contient des &eacute;l&eacute;ments vides,
     <function>prev</function> retournera &false; pour ces
     &eacute;l&eacute;ments aussi. Pour passer en revue tous les
     &eacute;l&eacute;ments, utilisez plut&ocirc;t <function>each</function>.
    </para>
    </warning>
   </para>
   <para>
    <function>prev</function> se comporte exactement comme
    <function>next</function>, mais il fait reculer le pointeur plut&ocirc;t que
    de l'avancer.
   </para>
   <para>
    Voir aussi
    <function>current</function>,
    <function>end</function>
    <function>next</function> et
    <function>reset</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.range">
  <refnamediv>
   <refname>range</refname>
   <refpurpose>
    Cr&eacute;e un tableau contenant un intervalle d'&eacute;l&eacute;ments
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>array</type><methodname>range</methodname>
     <methodparam><type>int</type><parameter>low</parameter></methodparam>
     <methodparam><type>int</type><parameter>high</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>range</function> retourne un tableau contenant tous les entiers
    depuis <parameter>low</parameter> jusqu'&agrave; <parameter>high</parameter>,
    inclus.
   </para>
   <para>
    Voir aussi <function>shuffle</function> (pour un exemple d'utilisation).
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.reset">
  <refnamediv>
   <refname>reset</refname>
   <refpurpose>
    Remet le pointeur interne de tableau au d&eacute;but
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>mixed</type><methodname>reset</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>reset</function> replace le pointeur de tableau
    <parameter>array</parameter> au premier &eacute;l&eacute;ment.
   </para>
   <para>
    <function>reset</function> retourne la valeur du premier &eacute;l&eacute;ment.
   </para>
   <para>
    Voir aussi
    <function>current</function>,
    <function>each</function>,
    <function>next</function>,
    <function>prev</function> et
    <function>reset</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.rsort">
  <refnamediv>
   <refname>rsort</refname>
   <refpurpose>Trie en ordre inverse</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>rsort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>rsort</function> effectue un tri en ordre d&eacute;croissant (du plus grand au
    plus petit).
    <example>
     <title>Exemple avec <function>rsort</function></title>
     <programlisting role="php">
&lt;?php
  $fruits = array("papaye","orange","banane","ananas");
  rsort($fruits);
  for (reset($fruits); list($key,$value) = each($fruits); ) {
    echo "fruits[$key] = ", $value, "\n";
}
?&gt;
     </programlisting>
    </example>
    Cet exemple va afficher:
    <computeroutput>
    fruits[0] = papaye
    fruits[1] = orange
    fruits[2] = banane
    fruits[3] = ananas
    </computeroutput>
    Les fruits ont &eacute;t&eacute; class&eacute;s dans l'ordre alphab&eacute;tique
    inverse.
   </para>
   <para>
    Voir aussi
    <function>array-multisort</function>,
    <function>arsort</function>,
    <function>asort</function>,
    <function>krsort</function>,
    <function>ksort</function>,
    <function>natsort</function>,
    <function>natcasesort</function>,
    <function>sort</function>,
    <function>uasort</function>,
    <function>uksort</function> et
    <function>usort</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.shuffle">
  <refnamediv>
   <refname>shuffle</refname>
   <refpurpose>M&eacute;lange les &eacute;l&eacute;ments d'un tableau</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>shuffle</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>shuffle</function> m&eacute;lange les &eacute;l&eacute;ments
    d'un tableau.
    <example>
     <title>Exemple avec <function>shuffle</function></title>
     <programlisting role="php">
&lt;?php
  $numbers = range (1,20);
  srand (time());
  shuffle ($numbers);
  while (list(, $number) = each ($numbers)) {
    echo "$number ";
}
?&gt;
     </programlisting>
    </example>
   </para>
   <para>
    Voir aussi
    <function>array-multisort</function>,
    <function>arsort</function>,
    <function>asort</function>,
    <function>krsort</function>,
    <function>ksort</function>,
    <function>natsort</function>,
    <function>natcasesort</function>,
    <function>rsort</function>,
    <function>sort</function>,
    <function>uasort</function>,
    <function>uksort</function> et
    <function>usort</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.sizeof">
  <refnamediv>
   <refname>sizeof</refname>
   <refpurpose>Retourne le nombre d'&eacute;l&eacute;ment d'un tableau</refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>sizeof</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>sizeof</function> retourne le nombre d'&eacute;l&eacute;ment d'un tableau.
   </para>
   <para>
    Voir aussi
    <function>count</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.sort">
  <refnamediv>
   <refname>sort</refname>
   <refpurpose>Trie le tableau </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>sort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>sort</function> trie le tableau <parameter>array</parameter>. Les
    &eacute;l&eacute;ments seront tri&eacute;s du plus petit au plus grand.
    <example>
     <title>Exemple avec <function>sort</function></title>
     <programlisting role="php">
&lt;?php
  $fruits = array("papaye","orange","banane","ananas");
  sort($fruits);
  for(reset($fruits); $key = key($fruits); next($fruits)) {
    echo "fruits[$key] = ".$fruits[$key]."\n";
  }
?&gt;
     </programlisting>
    </example>
    Cet exemple va afficher :
    <computeroutput>
    fruits[0] = ananas
    fruits[1] = banane
    fruits[2] = orange
    fruits[3] = papaye
    </computeroutput>
    Les fruits ont &eacute;t&eacute; class&eacute;s dans l'ordre alphab&eacute;tique.
   </para>
   <para>
    Voir aussi
    <function>array-multisort</function>,
    <function>arsort</function>,
    <function>asort</function>,
    <function>krsort</function>,
    <function>ksort</function>,
    <function>natsort</function>,
    <function>natcasesort</function>,
    <function>rsort</function>,
    <function>uasort</function>,
    <function>uksort</function> et
    <function>usort</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.uasort">
  <refnamediv>
   <refname>uasort</refname>
   <refpurpose>
    Trie d'un tableau en utilisant une fonction de comparaison d&eacute;finie par
    l'utilisateur.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>uasort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
     <methodparam><type>function</type><parameter>cmp_function</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>uasort</function> trie un tableau en conservant la correspondance entre les index
    et leurs valeurs. <function>uasort</function> sert essentiellement lors de tri de tableaux
    associatifs o&ugrave; l'ordre des &eacute;l&eacute;ments est significatif. La
    fonction de comparaison utilis&eacute;e est d&eacute;finie par l'utilisateur.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.uksort">
  <refnamediv>
   <refname>uksort</refname>
   <refpurpose>
    Trie un tableau par ses cl&eacute;s en utilisant une fonction de comparaison
    d&eacute;finie par l'utilisateur
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>uksort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
     <methodparam><type>function</type><parameter>cmp_function</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>uksort</function> trie les cl&eacute;s du tableau en utilisant une
    fonction d&eacute;finie par l'utilisateur. Si un tableau doit &ecirc;tre
    tri&eacute; avec un crit&egrave;re complexe, il est pr&eacute;f&eacute;rable
    d'utiliser <function>uksort</function>.
    <example>
     <title>Exemple avec <function>uksort</function></title>
     <programlisting role="php">
&lt;?php
  function mycompare($a, $b) {
    if ($a == $b) return 0;
    return ($a &gt; $b) ? -1 : 1;
  }
  $a = array(4 =&gt; "quatre", 3 =&gt; "trois", 20 =&gt; "vingt", 10 =&gt; "dix");
  uksort($a, mycompare);
  while(list($key, $value) = each($a)) {
    echo "$key: $value\n";
  }
?&gt;
     </programlisting>
    </example>
    Cet exemple affichera:
    <computeroutput>
    20: vingt
    10: dix
    4: quatre
    3: trois
    </computeroutput>
   </para>
   <para>
    Voir aussi
    <function>array-multisort</function>,
    <function>arsort</function>,
    <function>asort</function>,
    <function>krsort</function>,
    <function>ksort</function>,
    <function>natsort</function>,
    <function>natcasesort</function>,
    <function>rsort</function>,
    <function>sort</function>,
    <function>uasort</function> et
    <function>usort</function>.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.usort">
  <refnamediv>
   <refname>usort</refname>
   <refpurpose>
    Trie un tableau en utilisant une fonction de comparaison d&eacute;finie
    par l'utilisateur
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>void</type><methodname>usort</methodname>
     <methodparam><type>array</type><parameter>array</parameter></methodparam>
     <methodparam><type>function</type><parameter>cmp_function</parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>usort</function> va trier un tableau avec ses valeurs, en utilisant une fonction
    d&eacute;finie par l'utilisateur. Si un tableau doit &ecirc;tre tri&eacute;
    avec un crit&egrave;re complexe, il est pr&eacute;f&eacute;rable d'utiliser
    cette m&eacute;thode.
   </para>
   <para>
    La fonction de comparaison <parameter>cmp_function</parameter> doit retourner un entier,
    qui sera inf&eacute;rieur, &eacute;gal ou sup&eacute;rieur &agrave; z&eacute;ro
    suivant que le premier argument est consid&eacute;r&eacute; comme plus petit,
    &eacute;gal ou plus grand que le second argument. Si les deux arguments sont
    &eacute;gaux, leur ordre est ind&eacute;fini.
    <example>
     <title>Exemple avec <function>usort</function></title>
     <programlisting role="php">
&lt;?php
  function cmp($a,$b) {
    if ($a == $b) return 0;
    return ($a &lt; $b) ? -1 : 1;
  }
  $tableau = array(3,2,5,6,1);
  usort($a, "cmp");
  while(list($cle,$valeur) = each($tableau)) {
    echo "$cle: $valeur\n";
  }
?&gt;
     </programlisting>
    </example>
    Cet exemple va afficher :
    <computeroutput>
    0: 6
    1: 5
    2: 3
    3: 2
    4: 1
    </computeroutput>
    <note>
     <para>
      Evidemment dans ce cas trivial, <function>rsort</function> serait plus
      appropri&eacute;.
     </para>
    </note>
    <warning>
    <para>
     Les biblioth&egrave;ques de tri rapides sur lesquelles reposent PHP
     peuvent le conduire &agrave; un plantage, si la fonction de comparaison
     ne retourne pas une valeur coh&eacute;rente.
    </para>
    </warning>
   </para>
   <para>
    Voir aussi
    <function>array-multisort</function>,
    <function>arsort</function>,
    <function>asort</function>,
    <function>krsort</function>,
    <function>ksort</function>,
    <function>natsort</function>,
    <function>natcasesort</function>,
    <function>rsort</function>,
    <function>sort</function>,
    <function>uasort</function> et
    <function>uksort</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:
-->