<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision: 1.5 $ -->
 <reference id="ref.array">
  <title>Fun&ccedil;&otilde;es para a manipula&ccedil;&atilde;o de arrays</title>
  <titleabbrev>Arrays</titleabbrev>
  <partintro>
   <simpara>
    Essas fun&ccedil;&otilde;es permitem a intera&ccedil;&atilde;o e manipula&ccedil;&atilde;o de arrays de
    v&aacute;rias formas. Arrays s&atilde;o essenciais para armazenar, gerenciar, 
    operar sobre um conjunto de vari&aacute;veis.
   </simpara>
   <simpara>
    Arras simples e multidimensionais (matrizes) s&atilde;o suportados, e podem
    ser criados pelo usu&aacute;rio ou por outras fun&ccedil;&otilde;es.
    Existem diversas fun&ccedil;&otilde;es espec&iacute;ficas para bancos de dados para preencher
    arrays com os dados retornados em consultas, e v&aacute;rios outros tipos de fun&ccedil;&otilde;es
    tamb&eacute;m retornam arrays.
   </simpara>
  <para>
   Por favor, veja a se&ccedil;&atilde;o <link linkend="language.types.array">Arrays</link>
   do manual para uma explica&ccedil;&atilde;o mais detalhada sobre como arrays s&atilde;o
   implementados e utilizados no PHP.
  </para>
   <para>
    Veja tamb&eacute;m <function>is_array</function>, <function>explode</function>, 
    <function>implode</function>, <function>split</function> 
    e <function>join</function>.
   </para>
  </partintro>

  <refentry id="function.array">
   <refnamediv>
    <refname>array</refname>
    <refpurpose>
     Cria um array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>array</type><methodname>array</methodname>
      <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     Retorna um array de par&acirc;metros fornecidos. ndices podem ser atribuidos
     aos par&acirc;metros atrav&eacute;s do operador <literal>=&gt;</literal>.
    </para>
    <para>
     <note>
      <para>
       <function>array</function> &eacute; uma estrutura utilizada para representar
       literais de arrays, e n&atilde;o uma fun&ccedil;&atilde;o.
      </para>
     </note>
    </para>
    <para>
     A forma "index =&gt; values", separados por v&iacute;rgulas, definem &iacute;ndice e
     valores respectivamente. O &iacute;ndice por de ser do tipo string ou num&eacute;rico.
     Quando o &iacute;ndice &eacute; omitido, um &iacute;ndice num&eacute;rico inteiro &eacute; automaticamente
     gerado, come&ccedil;ando do 0. Se o &iacute;ndice &eacute; um inteiro, o pr&oacute;ximo &iacute;ndice a ser
     gerado ser&aacute; igual ao maior &iacute;ndice inteiro + 1. Note que quando dois
     &iacute;ndices id&ecirc;nticos s&atilde;o definidos,  o &uacute;ltimo sobrescreve o primeiro.
    </para>
    <para>
     O exemplo a seguir demonstra como criar um array com duas dimens&otilde;es, como
     especificar chaves em arrays associativos, e como definir &iacute;ndices
     num&eacute;ricos em arrays normais.
     <example>
      <title>Exemplo de <function>array</function></title>
      <programlisting role="php">
<![CDATA[
$frutas = array (
    "frutas"  => array ("a"=>"laranja", "b"=>"banana", "c"=>"melancia"),
    "numeros" => array (1, 2, 3, 4, 5, 6),
    "buracos"   => array ("primeiro", 5 => "segundo", "terceiro")
);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     <example>
      <title>ndices autom&aacute;ticos com <function>array</function></title>
      <programlisting role="php">
<![CDATA[
$array = array( 1, 1, 1, 1,  1, 8=>1,  4=>1, 19, 3=>13);
print_r($array);
]]>
      </programlisting>
      <para>
       vai mostrar : 
       <screen role="php">
<![CDATA[
Array 
(
    [0] => 1
    [1] => 1
    [2] => 1
    [3] => 13
    [4] => 1
    [8] => 1
    [9] => 19
)
]]>
       </screen>
      </para>
     </example>
     Note que o &iacute;ndice 3 &eacute; definido duas vezes, e ret&ecirc;m seu &uacute;ltimo valor
     13. O &iacute;ndice 4 &eacute; definido depois do &iacute;ndice 8, e o &iacute;ndice gerado depois
     dele foi 9, uma vez que o maior &iacute;ndice era 8.
    </para>
    <para>
     Esse exemplo cria um array com o &iacute;ndices a partir do 1.
     <example>
      <title>Array com &iacute;ndices a partir do 1 com <function>array</function></title>
      <programlisting role="php">
<![CDATA[
$trimestre  = array(1 => 'Janeiro', 'Fevereiro', 'Marco');
print_r($trimestre);
]]>
      </programlisting>
      <para>
       vai mostrar : 
       <screen>
<![CDATA[
Array 
(
    [1] => 'Janeiro'
    [2] => 'Fevereiro'
    [3] => 'Marco'
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     Veja tamb&eacute;m: <function>list</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-change-key-case">
   <refnamediv>
    <refname>array_change_key_case</refname>
    <refpurpose>Retorna um array com todas as chaves string em mai&uacute;sculo ou
    min&uacute;sculo</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> muda as chaves chaves do 
     array <parameter>input</parameter> para mai&uacute;sculo ou min&uacute;sculo. A mudan&ccedil;a
     depende do &uacute;ltimo par&acirc;metro opcional <parameter>case</parameter>.
     Voc&ecirc; pode passar duas constantes para ele,
     <constant>CASE_UPPER</constant> e
     <constant>CASE_LOWER</constant>. O padr&atilde;o &eacute; 
     <constant>CASE_LOWER</constant>. 
     Essa fun&ccedil;&atilde;o deixar&aacute; os &iacute;ndices num&eacute;ricos inalterados.
    </para>
    <example>
     <title>Exemplo de <function>array_change_key_case</function></title>
     <programlisting role="php">
<![CDATA[
$input_array = array("primeiRo" => 1, "segunDo" => 4);
print_r(array_change_key_case($input_array, CASE_UPPER);
]]>
     </programlisting>
     <para>
      A sa&iacute;da deste programa ser&aacute;:
      <screen>
<![CDATA[
Array
(
    [PRIMEIRO] => 1
    [SEGUNDO] => 2
)
]]>
      </screen>
     </para>
    </example>
   </refsect1>
  </refentry>

  <refentry id="function.array-chunk">
   <refnamediv>
    <refname>array_chunk</refname>
    <refpurpose>Divide um array em peda&ccedil;os</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> divide um array em diversos
     arrays tendo como tamanho o valor de <parameter>size</parameter>. 
     Voc&ecirc; provavelmente ter&aacute; um array com menos valores no final. 
     Voc&ecirc; gerar&aacute; arrays como membros de um array multidimensional com &iacute;ndices
     num&eacute;ricos que come&ccedil;am do 0.
    </para>
    <para>
     Passando o valor &true; para par&acirc;metro <parameter>preserve_keys</parameter>,
     voc&ecirc; pode for&ccedil;ar a preserva&ccedil;&atilde;o das chaves do array original. Se for
     passado o valor &false;, novos &iacute;ndices num&eacute;ricos ser&atilde;o usados em cada
     array resultante come&ccedil;ando do valor 0. O padr&atilde;o &eacute; &false;.
    </para>
    <example>
     <title><function>array_chunk</function> example</title>
     <programlisting role="php">
<![CDATA[
$input_array = array('a', 'b', 'c', 'd', 'e');
print_r(array_chunk($input_array, 2));
print_r(array_chunk($input_array, 2, TRUE));
]]>
     </programlisting>
     <para>
      A sa&iacute;da deste programa ser&aacute;:
      <screen>
<![CDATA[
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
        )

)
]]>
      </screen>
     </para>
    </example>
   </refsect1>
  </refentry>

  <refentry id="function.array-count-values">
   <refnamediv>
    <refname>array_count_values</refname>
    <refpurpose>Conta todos os valores de um array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> retorna um array utlizando os valores
     do array <parameter>input</parameter> como chaves e seus respectivos
     n&uacute;meros de ocorr&ecirc;ncias como valores.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_count_values</function></title>
      <programlisting role="php">
<![CDATA[
$array = array (1, "ola", 1, "mundo", "ola");
array_count_values ($array); // retorna o array (1=>2, "ola"=>2, "mundo"=>1)
]]>
      </programlisting>
     </example>     
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-diff">
   <refnamediv>
    <refname>array_diff</refname>
    <refpurpose>Calcula as diferen&ccedil;as entre arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> retorna um array contendo todos os
     valores de <parameter>array1</parameter> que n&atilde;o est&atilde;o presentes
     em nenhum dos outros argumentos.
     Note que as chaves s&atilde;o preservadas.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_diff</function></title>
      <programlisting role="php">
<![CDATA[
$array1 = array ("a" => "verde", "vermelho", "azul", "vermelho");
$array2 = array ("b" => "verde", "amarelo", "vermelho");
$result = array_diff ($array1, $array2);
]]>
      </programlisting>
     </example>
    </para>     
    <para>
     Isso faz com que <varname>$result</varname> tenha 
     <literal>array ("azul");</literal>. Ocorr&ecirc;ncias multiplas em
     $array1 s&atilde;o tratados da mesma forma.
    </para>
    <note>
     <simpara>
      Dois elementos s&atilde;o considerados iguais se, e somente se,  
      <literal>(string) $elem1 === (string) $elem2</literal>. Em palavras:
      quando a representa&ccedil;&atilde;o em string &eacute; a mesma.
      <!-- TODO: example of it... -->
     </simpara>
    </note>
    <warning>
     <simpara>
      N&atilde;o estava funcinando no PHP 4.0.4!
      <!-- TODO: when exactly was this broken?... -->
     </simpara>
    </warning>
    <para>
     Veja tamb&eacute;m <function>array_intersect</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-filter">
   <refnamediv>
    <refname>array_filter</refname>
    <refpurpose>
     Filtra os elementos de um array de acordo com uma fun&ccedil;&atilde;o
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> retorna um array contendo
     todos os elementos do array <parameter>input</parameter> filtrados
     de acordo com a fun&ccedil;&atilde;o aplicada. Se o array 
     <parameter>input</parameter> &eacute; associativo, ent&atilde;o as chaves
     s&atilde;o preservadas.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_filter</function></title>
      <programlisting role="php">
<![CDATA[
function impar($var) {
    return ($var % 2 == 1);
}

function par($var) {
    return ($var % 2 == 0); 
}

$array1 = array ("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array (6, 7, 8, 9, 10, 11, 12);

$impar_arr = array_filter($array1, "impar");
$par_arr = array_filter($array2, "par");
]]>
      </programlisting>
     </example>
    </para>     
    <para>
     Isso faz com que <varname>$impar_arr</varname> tenha 
     <literal>array ("a"=&gt;1, "c"=&gt;3, "e"=&gt;5);</literal>,
     e <varname>$par_arr</varname> tenha
     <literal>array (6, 8, 10, 12);</literal>,
    </para>
    <para>
     Veja tamb&eacute;m <function>array_map</function>,
     <function>array_reduce</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-flip">
   <refnamediv>
    <refname>array_flip</refname>
    <refpurpose>Inverte a rela&ccedil;&otilde;es entre chaves e valores</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&otilde;es</title>
     <methodsynopsis>
      <type>array</type><methodname>array_flip</methodname>
      <methodparam><type>array</type><parameter>trans</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_flip</function> retorna um <type>array</type> com
     com a rela&ccedil;&atilde;o entre as chaves e seus valores invertida, ou seja, 
     as chaves de <parameter>trans</parameter> passam a ser valores e
     os valores de <parameter>trans</parameter> passam a ser as chaves.
    </para>
    <para>
     Note que os valores de <parameter>trans</parameter> devem ser chaves
     v&aacute;lidas, ou seja, eles precisam ser <type>inteiros</type> ou <type>string</type>.
     Um aviso ser&aacute; mostrado se um valor &eacute; de um tipo inv&aacute;lido para chaves,
     e o par chave/valor em quest&atilde;o <emphasis>n&atilde;o ser&aacute; invertido</emphasis>.
    </para>
    <para>
     se um valor tem v&aacute;rias ocorr&ecirc;ncias, a &uacute;ltima chave ser&aacute; usada
     como valor, e todos os outros ser&atilde;o perdidos.  
    </para>
    <para>
     <function>array_flip</function> retorna &false;
     se falhar.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_flip</function></title>
      <programlisting role="php">
<![CDATA[
$trans = array_flip ($trans);
$original = strtr ($str, $trans);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_flip</function> : collision</title>
      <programlisting role="php">
<![CDATA[
$trans = array ("a" => 1, "b" => 1, "c" => 2);
$trans = array_flip ($trans);
// agora $trans &eacute; : array(1 => "b", 2 => "c");
]]>
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-fill">
   <refnamediv>
    <refname>array_fill</refname>
    <refpurpose>Preenche um array com valores</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> preenche um array com 
     o n&uacute;mero de entradas igual a <parameter>num</parameter> com o valor do 
     par&acirc;metro <parameter>value</parameter>, e chaves come&ccedil;ando a partir de 
     <parameter>start_index</parameter>.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_fill</function></title>
      <programlisting role="php">
<![CDATA[
$a = array_fill(5, 6, 'banana');

/*
$a agora tem os seguintes valores:

$a[5]  = "banana";
$a[6]  = "banana";
$a[7]  = "banana";
$a[8]  = "banana";
$a[9]  = "banana";
$a[10] = "banana";
*/
]]>
      </programlisting>
     </example>     
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-intersect">
   <refnamediv>
    <refname>array_intersect</refname>
    <refpurpose>Calcula a interse&ccedil;&atilde;o entre arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> retorna um array
     contendo todos os valores de <parameter>array1</parameter>
     que est&atilde;o presentes nos outros argumentos.
     Note que as chaves s&atilde;o preservadas.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_intersect</function></title>
      <programlisting role="php">
<![CDATA[
$array1 = array ("a" => "verde", "vermelho", "azul");
$array2 = array ("b" => "verde", "amarelo", "vermelho");
$result = array_intersect ($array1, $array2);
]]>
      </programlisting>
     </example>
    </para>     
    <para>
     Isso faz com que <varname>$result</varname> tenha <literal>array ("a"
     =&gt; "verde", "vermelho");</literal>
    </para>
    <note>
     <simpara>
       Dois elementos s&atilde;o considerados iguais se, e somente se, 
      <literal>(string) $elem1 === (string) $elem2</literal>. Em palavras:
      quando a representa&ccedil;&atilde;o em string &eacute; a mesma.
      <!-- TODO: example of it... -->
     </simpara>
    </note>
    <warning>
     <simpara>
      Essa fun&ccedil;&atilde;o n&atilde;o funcionava no PHP 4.0.4!
      <!-- TODO: when exactly was this broken?... -->
     </simpara>
    </warning>
    <para>
     Veja tamb&eacute;m <function>array_diff</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-key-exists">
   <refnamediv>
    <refname>array_key_exists</refname>
    <refpurpose>Checa se uma chave existe num array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>bool</type><methodname>array_key_exists</methodname>
      <methodparam><type>mixed</type><parameter>key</parameter></methodparam>
      <methodparam><type>array</type><parameter>search</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_key_exists</function> retorna &true; se a chave
     <parameter>key</parameter> existe no array.
     <parameter>key</parameter> pode ser qualquer valor poss&iacute;vel para uma
     chave de um array.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_key_exists</function></title>
      <programlisting role="php">
<![CDATA[
$busca_array = array("primeiro" => 1, "segundo" => 4);
if (array_key_exists("primeiro", $busca_array)) {
    echo "O elemento 'primeiro' est&aacute; no array!";
}
]]>
      </programlisting>
     </example>
    </para>
    <note>
     <simpara>
      O nome dessa fun&ccedil;&atilde;o &eacute; <function>key_exists</function>
      no PHP vers&atilde;o 4.0.6.
     </simpara>
    </note>
    <para>
     Veja tamb&eacute;m <function>isset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-keys">
   <refnamediv>
    <refname>array_keys</refname>
    <refpurpose>Retorna todas as chaves de um array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> retorna as chaves, num&eacute;ricas e
     string, do array <parameter>input</parameter>.
    </para>
    <para>
     Se o par&acirc;metro opcional <parameter>search_value</parameter> for
     especificado, ent&atilde;o apenas as chaves para esse valor s&atilde; retornadas. 
     Do contr&aacute;rio, todas as chaves de <parameter>input</parameter> ser&atilde;ao retornadas.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_keys</function></title>
      <programlisting role="php">
<![CDATA[
$array = array (0 => 100, "cor" => "vermelho");
array_keys ($array);       // retorna o array (0, "color")

$array = array ("azul", "vermelho", "verde", "azul", "azul");
array_keys ($array, "azul");  //  retorna o array (0, 3, 4) 

$array = array ("cor" => array("azul", "vermelho", "verde"), "tamanho" => array("pequeno", "medio", "grande"));
array_keys ($array);  //  retorna o array ("cor", "tamanho") 
]]>
      </programlisting>
     </example>
    </para>
    <note>
     <para>
      Essa fun&ccedil;&atilde;o adicionada no PHP 4,abaixo est&aacute; uma implementa&ccedil;&atilde;o
      para aqueles que ainda usam PHP 3.
      <example>
       <title>
        Implementa&ccedil;&atilde;o de <function>array_keys</function> para usu&aacute;rios do PHP 3
       </title>
       <programlisting role="php">
<![CDATA[
function array_keys ($arr, $term="") {
    $t = array();
    while (list($k,$v) = each($arr)) {
        if ($term && $v != $term) {
            continue;
            $t[] = $k;
        }
        return $t;
    }
}
]]>
       </programlisting>
      </example>
     </para>
    </note>
    <para>
     Veja tamb&eacute;m <function>array_values</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-map">
   <refnamediv>
    <refname>array_map</refname>
    <refpurpose>
     Aplica uma fun&ccedil;&atilde;o em todos os elementos dos arrays dados
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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>arr2...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_map</function> retorna um array contendo todos
     os elementos de <parameter>arr1</parameter> depois de aplicada
     a fun&ccedil;&atilde;o callback em cada um.  O n&uacute;mero de par&acirc;metros que a fun&ccedil;&atilde;o
     callback aceita deve coincidir com o n&uacute;mero de arrays passados para a
     <function>array_map</function>
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_map</function></title>
      <programlisting role="php">
<![CDATA[
function cubo($n) {
    return $n*$n*$n;
}

$a = array(1, 2, 3, 4, 5);
$b = array_map("cubo", $a);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Isso resultar&aacute; em <varname>$b</varname> contendo
     <literal>array (1, 8, 27, 64, 125);</literal>
    </para>
    <para>
     <example>
      <title><function>array_map</function> - usando mais arrays</title>
      <programlisting role="php">
<![CDATA[
function mostrar_Espanhol($n, $m) {
    return "O n&uacute;mero $n &eacute; chamado de $m na Espanha";
}

function map_Espanhol($n, $m) {
    return array ($n => $m);
}

$a = array(1, 2, 3, 4, 5);
$b = array("uno", "dos", "tres", "cuatro", "cinco");

$c = array_map("mostrar_Espanhol", $a, $b);

print_r($c);

// mostrar&aacute;:
// Array 
// (
//     [0] => O n&uacute;mero 1 &eacute; chamado de uno na Espanha
//     [1] => O n&uacute;mero 2 &eacute; chamado de dos na Espanha
//     [2] => O n&uacute;mero 3 &eacute; chamado de tres na Espanha
//     [3] => O n&uacute;mero 4 &eacute; chamado de cuatro na Espanha
//     [4] => O n&uacute;mero 5 &eacute; chamado de cinco na Espanha
// )

$d = array_map("map_Espanhol", $a , $b);

print_r($d);

// will output:
// Array 
// (
//     [0] => Array
//         (
//             [1] => uno
//         )
// 
//     [1] => Array
//         (
//             [2] => dos
//         )
// 
//     [2] => Array
//         (
//             [3] => tres
//         )
// 
//     [3] => Array
//         (
//             [4] => cuatro
//         )
// 
//     [4] => Array
//         (
//             [5] => cinco
//         )
// 
// )
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Normalmente quando se usa dois ou mais arrays, eles devem ter o mesmo tamanho
     porque a fun&ccedil;&atilde;o callback &eacute; aplicada paralelamente aos elementos
     correpondentes.
     Se os arrays tem tamanhos diferentes, o menos array ser&aacute; extendido com
     elementos em branco.
    </para>
    <para>
     Um modo interessante de usar essa fun&ccedil;&atilde;o &eacute; na constru&ccedil;&atilde;o de um array de
     arrays, o que pode ser facilmente feito usando &null;
     como o nome da fun&ccedil;&atilde;o callback.
    </para>
    <para>
     <example>
      <title>Criando um array de arrays</title>
      <programlisting role="php">
<![CDATA[
$a = array(1, 2, 3, 4, 5);
$b = array("um", "dois", "tres", "quatro", "cinco");
$c = array("uno", "dos", "tres", "cuatro", "cinco");

$d = array_map(null, $a, $b, $c);
print_r($d);

// mostrar&aacute;:
// Array
// (
//     [0] => Array
//         (
//             [0] => 1
//             [1] => um
//             [2] => uno
//         )
// 
//     [1] => Array
//         (
//             [0] => 2
//             [1] => dois
//             [2] => dos
//         )
// 
//     [2] => Array
//         (
//             [0] => 3
//             [1] => tres
//             [2] => tres
//         )
// 
//     [3] => Array
//         (
//             [0] => 4
//             [1] => quatro
//             [2] => cuatro
//         )
// 
//     [4] => Array
//         (
//             [0] => 5
//             [1] => cinco
//             [2] => cinco
//         )
// 
// )
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Veja tamb&eacute;m <function>array_filter</function>,
     <function>array_reduce</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-merge">
   <refnamediv>
    <refname>array_merge</refname>
    <refpurpose>Funde dois ou mais arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> funde os elementos dois ou mais 
     arrays de forma que os elementos de um s&atilde;o colocados no final
     do array anterior. Retorna esse array resultante.
    </para>
    <para>
     Se os arrays dados t&ecirc;m as mesmas chaves string, ent&atilde;o o &uacute;ltimo
     valor para uma chave ir&aacute; sobrescrever todos os outros. Se, no entanto,
     os arrays tem as mesmas chaves num&eacute;ricas, o &uacute;ltimo valor para uma chave
     n&atilde;o sobrescrever&aacute; o valor original, e sim adicionado ao array
     resultante.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_merge</function></title>
      <programlisting role="php">
<![CDATA[
$array1 = array ("cor" => "vermelho", 2, 4);
$array2 = array ("a", "b", "cor" => "verde", "forma" => "trapezoide", 4);
$result = array_merge ($array1, $array2);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     O array resultante ser&aacute; <literal>array("cor" =&gt; "verde", 2, 4,
     "a", "b", "forma" =&gt; "trapezoide", 4)</literal>.
    </para>
    <para>
     Veja tamb&eacute;m <function>array_merge_recursive</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-merge-recursive">
   <refnamediv>
    <refname>array_merge_recursive</refname>
    <refpurpose>Funde dois ou mais arrays recursivamente</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> funde os elementos de 
     dois ou mais de forma que os elementos de um s&atilde;o colocados
     no final do array anterior. Retorna esse array resultante.
    </para>
    <para>
     Se os arrays dados tem as mesmas chaves string, ent&atilde;o os valores para
     uma chave s&atilde;o fundidos em um array, e isso &eacute; feito recursivamente,
     sendo que se um dos valores for um array tamb&eacute;m, este fun&ccedil;&atilde;o ir&aacute; fundi-lo
     com os valores correspondentes no array resultante tamb&eacute;m. Se, no
     entanto, os arrays tem as mesmas chaves num&eacute;ricas, o &uacute;ltimo valor para
     uma chave n&atilde;o sobrescrever&aacute; o valor original, e sim adicionado ao array
     resultante.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_merge_recursive</function></title>
      <programlisting role="php">
<![CDATA[
$ar1 = array ("cor" => array ("favorita" => "vermelho"), 5);
$ar2 = array (10, "cor" => array ("favorita" => "verde", "azul"));
$result = array_merge_recursive ($ar1, $ar2);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     O array resultante ser&aacute; <literal>array ("cor" =&gt; array
     ("favorita" =&gt; array ("vermelho", "verde"), "azul"), 5, 10)</literal>.
    </para>
    <para>
     Veja tamb&eacute;m <function>array_merge</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-multisort">
   <refnamediv>
    <refname>array_multisort</refname>
    <refpurpose>Classifica m&uacute;ltiplos arrays ou multi-dimensionais</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>bool</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> pode ser usada para classificar
     v&aacute;rios arrays de uma vez ou apenas um array multi-dimensional de acordo com
     uma das dimens&otilde;es. A associa&ccedil;&atilde;o entre chaves e valores &eacute; mantida.
    </para>
    <para>
     Os arrays dados s&atilde;o tratados como colunas de uma tabela a ser 
     classificada pelas linhas - isso lembra a funcionalidade da cl&aacute;usula
     ORDER BY da SQL. O primeiro array &eacute; o principal na classifica&ccedil;&atilde;o. As
     linhas (valores) no primeiro array serve de base para a classifica&ccedil;&atilde;o do pr&oacute;ximo,
     e assim por diante.
    </para>
    <para>
     A estrutura de argumentos dessa fun&ccedil;&atilde;o n&atilde;o &eacute; muito normal, mas
     bastante flex&iacute;vel. O primeiro argmento de todos deve ser um array.
     Subsequentemente, cada argumento pode ser um array ou um dos sinais de
     classifica&ccedil;&atilde;o da lista a seguir.
    </para>
    <para>
     Sinais de ordem de classifica&ccedil;&atilde;o:
     <itemizedlist>
      <listitem>
       <simpara>SORT_ASC - classifica na ordem crescente</simpara>
      </listitem>
      <listitem>
       <simpara>SORT_DESC - classifica na ordem descrescente</simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para>
     Sinais de tipos de classifica&ccedil;&atilde;o:
     <itemizedlist>
      <listitem>
       <simpara>SORT_REGULAR - compara os elementos normalmente</simpara>
      </listitem>
      <listitem>
       <simpara>SORT_NUMERIC - compara os elementos como itens num&eacute;ricos</simpara>
      </listitem>
      <listitem>
       <simpara>SORT_STRING - compara os elementos como strings</simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para>
     N&atilde;o podem existir dois sinais de classifica&ccedil;&atilde;o do mesmo tipo
     especificados depois de um mesmo array. Apenas um. Os sinais de classifica&ccedil;&atilde;o
     especificados depois de um array se aplicam apenas para esse array - a
     eles s&atilde;o atribu&iacute;dos por padr&atilde;o os valores SORT_ASC e SORT_REGULAR depois
     de cada novo argumento do tipo array.
    </para>
    <para>
     Retorna &true; se obtiver sucesso, &false;
     se falhar.
    </para>
    <para>
     <example>
      <title>Classificando m&uacute;ltiplos arrays</title>
      <programlisting role="php">
<![CDATA[
$ar1 = array ("10", 100, 100, "a");
$ar2 = array (1, 3, "2", 1);
array_multisort ($ar1, $ar2);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Nesse exemplo, depois da classifica&ccedil;&atilde;o, o primeiro array ter&aacute; 1-, "a",
     100, 100. O segundo conter&aacute; 1, 1, "2", 3. Os elementos do segundo array
     que correpondem aos do primeiro (100 e 100) tamb&eacute;m foram classificados.
    </para>
    <para>
     <example>
      <title>Classificando um array multi-dimensional</title>
      <programlisting role="php">
<![CDATA[
$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);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Nesse exemplo, depois da classifica&ccedil;&atilde;o, o primeiro array ter&aacute; 10, 100,
     100, "a" (foi classificado como strings em ordem crescente), e o segundo
     conter&aacute; 1, 3, "2", 1 (classificado como n&uacute;meros, em ordem descrescente).
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-pad">
   <refnamediv>
    <refname>array_pad</refname>
    <refpurpose>
     Expande um array para um certo comprimento com um certo valor
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> retorna uma c&oacute;pia de 
     <parameter>input</parameter> expandido para o comprimento especificado
     por <parameter>pad_size</parameter> com o valor
     <parameter>pad_value</parameter>. Se
     <parameter>pad_size</parameter> for positivo ent&atilde;o o array &eacute; 
     expandido pela direita, se for negativo, pela esquerda. Se o 
     valor absoluto de <parameter>pad_size</parameter> for menor ou igual
     ao comprimento de <parameter>input</parameter>, ent&atilde;o ele permanece
     inalterado.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_pad</function></title>
      <programlisting role="php">
<![CDATA[
$input = array (12, 10, 9);

$result = array_pad ($input, 5, 0);
// result is array (12, 10, 9, 0, 0)

$result = array_pad ($input, -7, -1);
// result is array (-1, -1, -1, -1, 12, 10, 9)

$result = array_pad ($input, 2, "noop");
// not padded
]]>
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-pop">
   <refnamediv>
    <refname>array_pop</refname>
    <refpurpose>Retira um elemento do final do array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>mixed</type><methodname>array_pop</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_pop</function> retira e retorna o &uacute;ltimo
     valor de <parameter>array</parameter>, diminuindo-o
     <parameter>array</parameter> em um elemento.
     Se <parameter>array</parameter> estiver vazio (ou se n&atilde;o for um array), 
     o valor &null; &eacute; retornado.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_pop</function></title>
      <programlisting role="php">
<![CDATA[
$cesta = array ("laranja", "melancia", "morango");
$fruta = array_pop ($cesta);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Depois disso, <varname>$cesta</varname> ter&aacute; dois elementos:
     "laranja" e "melancia", and <varname>$fruta</varname> ter&aacute;
     "morango".
    </para>
    <para>
     Veja tamb&eacute;m <function>array_push</function>,
     <function>array_shift</function>, e
     <function>array_unshift</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-push">
   <refnamediv>
    <refname>array_push</refname>
    <refpurpose>
     Adiciona um ou mais elementos no final de um array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> trata
     <parameter>array</parameter> como uma pilha, e adiciona
     as vari&aacute;veis passadas como argumentos no final de <parameter>array</parameter>.
     O comprimento de <parameter>array</parameter> aumenta de acordo com o
     n&uacute;mero de vari&aacute;veis adicionadas.. Tem o mesmo efeito de:
     <programlisting role="php">
<![CDATA[
$array[] = $var;
]]>
     </programlisting>
     repetido para cada argumento <parameter>var</parameter>.
    </para>
    <para>
     Retorna o novo n&uacute;mero de elementos do array.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_push</function></title>
      <programlisting role="php">
<![CDATA[
$pilha = array (1, 2);
array_push ($pilha, "+", 3);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Esse exemplo resultar&aacute; em <varname>$pilha</varname> contendo 4
     elementos: 1, 2, "+", e 3.
    </para>
    <para>
     Veja tamb&eacute;m: <function>array_pop</function>,
     <function>array_shift</function>, e
     <function>array_unshift</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-rand">
   <refnamediv>
    <refname>array_rand</refname>
    <refpurpose>
     Pega um ou mais elementos aleat&oacute;rios do array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> &eacute; bastante &uacute;til quando se quer
     pegar aleatoriamente um ou mais elementos de um array. Ela recebe 
     o array <parameter>input</parameter> e outro argumento opcional
     <parameter>num_req</parameter> o qual especifica quantos elementos
     se quer pegar - se n&atilde;o for especificado, o padr&atilde;o &eacute; 1.
    </para>
    <para>
     Se estiver pegando apenas um elemento , <function>array_rand</function>
     retorna a chave para este elemento aleat&oacute;rio. De outra forma, ele retorna
     um array com as chaves desses elementos aleat&oacute;rios. Assim &eacute; poss&iacute;vel
     pegar chaves e valores aleat&oacute;rios.
    </para>
    <para>
     N&atilde;o esque&ccedil;a de chamar a fun&ccedil;&atilde;o <function>srand</function> para disparar 
     o gerador de n&uacute;meros aleat&oacute;rios.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_rand</function></title>
      <programlisting role="php">
<![CDATA[
srand ((float) microtime() * 10000000);
$input = array ("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
$rand_keys = array_rand ($input, 2);
print $input[$rand_keys[0]]."\n";
print $input[$rand_keys[1]]."\n";
]]>
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>
  
  <refentry id="function.array-reverse">
   <refnamediv>
    <refname>array_reverse</refname>
    <refpurpose>
     Retorna um array com os elementos na ordem inversa
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>array</type><methodname>array_reverse</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>bool</type><parameter>preserve_keys</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_reverse</function> recebe o argumento
     <parameter>array</parameter> e retorna um novo array com ordem
     dos elementos invertida, preservando as chaves se o argumento
     <parameter>preserve_keys</parameter> for &true;.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_reverse</function></title>
      <programlisting role="php">
<![CDATA[
$input = array ("php", 4.0, array ("verde", "vermelho"));
$result = array_reverse ($input);
$result_keyed = array_reverse ($input, TRUE);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Isso far&aacute; com que <varname>$result</varname> e
     <varname>$result_keyed</varname> sejam <literal>array(array
     ("green", "red"), 4.0, "php")</literal>. Mas
     <varname>$result_keyed[0]</varname> ainda ser&aacute;
     <literal>"php"</literal>.
    </para>
    <note>
     <para>
      O segundo argumento foi adicionado no PHP 4.0.3.
     </para>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.array-reduce">
   <refnamediv>
    <refname>array_reduce</refname>
    <refpurpose>
     Reduz um array para um &uacute;nico elemento atrav&eacute;s de um processo iterativo
     utilizando uma fun&ccedil;&atilde;o de callback.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> aplica iterativamente a fun&ccedil;&atilde;o
     <parameter>callback</parameter> nos elementos de <parameter>input</parameter>, 
     de forma a reduzi-lo a um &uacute;nico valor. Se o argumento opcional <parameter>initial</parameter>
     for passado, ele ser&aacute; utlizado no in&iacute;cio do processo, ou como
     um resultado final se o array estiver vazio.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_reduce</function></title>
      <programlisting role="php">
<![CDATA[
function soma($v, $w) {
    $v += $w;
    return $v;
}

function multiplicacao($v, $w) {
    $v *= $w;
    return $v;
}

$a = array(1, 2, 3, 4, 5);
$x = array();
$b = array_reduce($a, "soma");
$c = array_reduce($a, "multiplicacao", 10);
$d = array_reduce($x, "soma", 1);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Isso resultar&aacute; em <varname>$b</varname> contendo
     <literal>15</literal>, <varname>$c</varname> contendo
     <literal>1200</literal> (= 1*2*3*4*5*10), e
     <varname>$d</varname> contendo <literal>1</literal>.
    </para>
    <para>
     Veja tamb&eacute;m <function>array_filter</function>,
     <function>array_map</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-shift">
   <refnamediv>
    <refname>array_shift</refname>
    <refpurpose>
     Retira o primeiro elemento de um array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>mixed</type><methodname>array_shift</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_shift</function> retira o primeiro elemento de 
     <parameter>array</parameter> e o retorna, diminuindo
     <parameter>array</parameter> em um elemento e movendo todos os outros
     para tr&aacute;s. Se <parameter>array</parameter> estiver vazio (ou se n&atilde;o for
     um array), o valor &null; &eacute; retornado.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_shift</function></title>
      <programlisting role="php">
<![CDATA[
$args = array ("-v", "-f");
$opt = array_shift ($args);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Isso resultaria em <varname>$args</varname> contendo apenas o elemento
     "-f", e <varname>$opt</varname> sendo "-v".
    </para>
    <para>
     Veja tamb&eacute;m <function>array_unshift</function>,
     <function>array_push</function>, e
     <function>array_pop</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-slice">
   <refnamediv>
    <refname>array_slice</refname>
    <refpurpose>Extrai uma "fatia" de um array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> retorna a sequ&ecirc;ncia de elementos
     de <parameter>array</parameter> especificada pelos par&acirc;metros
     <parameter>offset</parameter> e <parameter>length</parameter>.
    </para>
    <para>
     Se <parameter>offset</parameter> for positivo, a sequ&ecirc;ncia
     come&ccedil;ar&aacute; no in&iacute;cio de <parameter>array</parameter>.  Se
     <parameter>offset</parameter> for negativo, a sequ&ecirc;ncia
     come&ccedil;ar&aacute; dessa dist&acirc;ncia do final de <parameter>array</parameter>.
    </para>
    <para>
     Se <parameter>length</parameter> for especificado e positivo, ent&atilde;o
     a sequ&ecirc;ncia ter&aacute; essa quantidade de elementos. Se
     <parameter>length</parameter> for especificado e negativo ent&atilde;o
     a sequ&ecirc;ncia para dessa quantidade elementos a partir do final do
     array. Se for omitido, ent&atilde;o a sequ&ecirc;ncia ter&aacute; todos os elementos 
     a partir de <parameter>offset</parameter> at&eacute; o final de 
     <parameter>array</parameter>.
    </para>
    <para>
     <example>
      <title>Exemplos de <function>array_slice</function></title>
      <programlisting role="php">
<![CDATA[
$input = array ("a", "b", "c", "d", "e");

$output = array_slice ($input, 2);      // retorna "c", "d", e "e"
$output = array_slice ($input, 2, -1);  // retorna "c", "d"
$output = array_slice ($input, -2, 1);  // retorna "d"
$output = array_slice ($input, 0, 3);   // retorna "a", "b", e "c"
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Veja tamb&eacute;m <function>array_splice</function>.
    </para>     
   </refsect1>
  </refentry>

  <refentry id="function.array-splice">
   <refnamediv>
    <refname>array_splice</refname>
    <refpurpose>
     Remove uma regi&atilde;o do array e substitui por outros elementos
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> remove os elementos especificados
     por <parameter>offset</parameter> e
     <parameter>length</parameter> do array
     <parameter>input</parameter>, e os substitui com os elementos
     do array <parameter>replacement</parameter>, se for especificado.
    </para>
    <para>
     Se <parameter>offset</parameter> for positivo ent&atilde;o o come&ccedil;o da
     regi&atilde;o a ser removida ser&aacute; nessa posi&ccedil;&atilde;o a partir do in&iacute;cio do array
     <parameter>input</parameter>. Se <parameter>offset</parameter> for negativo
     ent&atilde;o o &iacute;nicio ser&aacute; dessa dist&acirc;ncia do final de <parameter>input</parameter>.
    </para>
    <para>
     Se <parameter>length</parameter> for omitido, todos os elementos
     a partir de <parameter>offset</parameter> at&eacute; o final do array s&atilde;o
     removidos.  Se <parameter>length</parameter> for especificado e positivo, ent&atilde;o
     essa quantidade de elementos ser&aacute; removida. Se <parameter>length</parameter> 
     for especificado e negativo ent&atilde;o o final da regi&atilde;o a ser removida ser&aacute; 
     nessa quantidade de elementos a partir do final do array. 
     Dica: para remover todos elementos a partir de <parameter>offset</parameter> 
     at&eacute; o final do array quando <parameter>replacement</parameter> tamb&eacute;m &eacute; especificado, use
     <literal>count($input)</literal> para o argumento <parameter>length</parameter>.
    </para>
    <para>
     Se o array <parameter>replacement</parameter> for especificado, ent&atilde;o
     os elementos removidos ser&atilde;o substituidos pelo elementos desse array.
     Se <parameter>offset</parameter> e
     <parameter>length</parameter> dados de forma que nada ser&aacute; removido,
     ent&atilde;o os elementos de <parameter>replacement</parameter> ser&atilde;o inseridos
     no lugar especificado por <parameter>offset</parameter>. 
     Dica: se a substitui&ccedil;&atilde;o for de apenas um elemento
     ent&atilde;o n&atilde;o ser&aacute; necess&aacute;rio colocar <literal>array()</literal>
     para ele, a n&atilde;o ser que elementos seja um array.
    </para>
    <para>
     As seguintes equival&ecirc;ncias abaixo s&atilde;o v&aacute;lidas:
     <programlisting role="php">
<![CDATA[
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)
]]>
     </programlisting>
    </para>
    <para>
     Retorna um array contendo os elementos removidos.
    </para>
    <para>
     <example>
      <title>Exemplos de <function>array_splice</function></title>
      <programlisting role="php">
<![CDATA[
$input = array ("vermelho", "verde", "azul", "amarelo");
array_splice ($input, 2);      
// $input ser&aacute; agora array ("vermelho", "verde")

$input = array ("vermelho", "verde", "azul", "amarelo");
array_splice ($input, 1, -1);  
// $input ser&aacute; agora array ("vermelho", "amarelo")

$input = array ("vermelho", "verde", "azul", "amarelo");
array_splice ($input, 1, count($input), "laranja");  
// $input ser&aacute; agora array ("vermelho", "laranja")

$input = array ("vermelho", "verde", "azul", "amarelo");
array_splice ($input, -1, 1, array("preto", "marrom")); 
// $input ser&aacute; agora array ("vermelho", "verde", "azul", "preto", "marron")
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Veja tamb&eacute;m <function>array_slice</function>.
    </para>
   </refsect1>
  </refentry>
 
  <refentry id="function.array-sum">
   <refnamediv>
    <refname>array_sum</refname>
    <refpurpose>
     Calcula a soma dos elementos de um array 
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>mixed</type><methodname>array_sum</methodname>
      <methodparam><type>array</type><parameter>arr</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_sum</function> retorna a soma dos valores
     de um array como inteiro ou real.
    </para>
    <para>
     <example>
      <title>Exemplos de <function>array_sum</function></title>
      <programlisting role="php">
<![CDATA[
$a = array(2, 4, 6, 8);
echo "sum(a) = ".array_sum($a)."\n";
// imprime: sum(a) = 20

$b = array("a"=>1.2,"b"=>2.3,"c"=>3.4);
echo "sum(b) = ".array_sum($b)."\n";
// imprime: sum(b) = 6.9
]]>
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-unique">
   <refnamediv>
    <refname>array_unique</refname>
    <refpurpose>Remove o valores duplicados de um array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>array</type><methodname>array_unique</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_unique</function> recebe o argumento
     <parameter>array</parameter> e retorna um novo array sem valores
     duplicados.
    </para>
    <para>
     Note que as chaves s&atilde;o preservadas. <function>array_unique</function> ir&aacute;
     manter a primeira chave encontrada para cada valor, e ignorar
     as chaves posteriores.
    </para>
    <note>
     <simpara>
      Dois elementos s&atilde;o considerados iguais se, e somente se,  
      <literal>(string) $elem1 === (string) $elem2</literal>. Em palavras:
      quando a represeta&ccedil;&atilde;o em string &eacute; a mesma.
      <!-- TODO: example of it... -->
     </simpara>
     <simpara>
      O primeiro ser&aacute; usado.
     </simpara>
    </note>
    <warning>
     <simpara>
      Essa fun&ccedil;&atilde;o n&atilde;o funcionava no PHP 4.0.4!
      <!-- TODO: when exactly was this broken?... -->
     </simpara>
    </warning>
    <para>
     <example>
      <title>Exemplo de <function>array_unique</function></title>
      <programlisting role="php">
<![CDATA[
$input = array ("a" => "verde", "vermelho", "b" => "verde", "azul", "vermelho");
$result = array_unique ($input);
print_r($result);
// a sa&iacute;da ser&aacute; :
//Array
//(
//    [a] => verde
//    [0] => vermelho
//    [1] => azul
//)
]]>
      </programlisting>
     </example>
    </para>
    <para>
     <example>
      <title><function>array_unique</function> e tipos</title>
      <programlisting role="php">
<![CDATA[
$input = array (4,"4","3",4,3,"3");
$result = array_unique ($input);
var_dump($result);

/* sa&iacute;da:
array(2) {
   [0]=>
   int(4)
   [1]=>
   string(1) "3"
}
*/
]]>
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-unshift">
   <refnamediv>
    <refname>array_unshift</refname>
    <refpurpose>
     Adiciona um ou mais elementos no in&iacute;cio de um array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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> adiciona os elementos passados como
     argumentos no in&iacute;cio de <parameter>array</parameter>. Note que a lista
     de elementos &eacute; adicionada como um todo, de forma que eles ficam na
     mesma ordem.
    </para>
    <para>
     Retorna o novo n&uacute;mero de elementos de <parameter>array</parameter>.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_unshift</function></title>
      <programlisting role="php">
<![CDATA[
$queue = array ("p1", "p3");
array_unshift ($queue, "p4", "p5", "p6");
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Isso resultaria em <varname>$queue</varname> contendo 5
     elementos: "p4", "p5", "p6", "p1", e "p3".
    </para>
    <para>
     Veja tamb&eacute;m <function>array_shift</function>,
     <function>array_push</function>, e
     <function>array_pop</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-values">
   <refnamediv>
    <refname>array_values</refname>
    <refpurpose>Retorna todos os valores de um array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>array</type><methodname>array_values</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_values</function> retorna todos os valores do array
     <parameter>input</parameter>.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>array_values</function></title>
      <programlisting role="php">
<![CDATA[
$array = array ("tamanho" => "G", "cor" => "dourado");
array_values ($array);    // retorna o array ("G", "dourado")
]]>
      </programlisting>
     </example>
    </para>
    <note>
     <para>
      Essa fun&ccedil;&atilde;o foi adicionada no PHP 4, abaixo segue uma implementa&ccedil;&atilde;o para
      aqueles que ainda usam PHP 3.
      <example>
       <title>
        Implementa&ccedil;&atilde;o de <function>array_values</function> para PHP 3
        users
       </title>
       <programlisting role="php">
<![CDATA[
function array_values ($arr) {
    $t = array();
    while (list($k, $v) = each ($arr)) {
        $t[] = $v;
    }
    return $t;
}
]]>
       </programlisting>
      </example>
     </para>
    </note>
    <para>
     Veja tamb&eacute;m <function>array_keys</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-walk">
   <refnamediv>
    <refname>array_walk</refname>
    <refpurpose>
     Aplica uma determinada func&atilde;o em cada elemento de um array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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 choice="opt"><type>mixed</type><parameter>userdata</parameter></methodparam>
     </methodsynopsis>
    <simpara>
     Aplica uma fun&ccedil;&atilde;o definida pelo usu&aacute;rio nomeada pelo argumento 
     <parameter>func</parameter> em cada elemento de <parameter>arr</parameter>.
     <parameter>func</parameter> ter&aacute; como primeiro o argumento o valor do
     elemento e sua chave como segndo par&acirc;metro.  Se
     <parameter>userdata</parameter> for especificado, ele ser&aacute; usado como
     terceiro argumento da fun&ccedil;&atilde;o do usu&aacute;rio. <parameter>func</parameter> 
     deve ser uma fun&ccedil;&atilde;o definida pelo usu&aacute;rio, e n&atilde;o uma fun&ccedil;&atilde;o nativa do PHP.
     Dessa forma, voc&ecirc; n&atilde;o pode usar <function>array_walk</function> juntamente com
     <function>str2lower</function>, primeiro deve ser definida uma fun&ccedil;&atilde;o do
     usu&aacute;rio, e depois pass&aacute;-la como argumento.
    </simpara>
    <simpara>
     Se <parameter>func</parameter> necessita de mais de dois ou tr&ecirc;s
     argumentos, dependendo de <parameter>userdata</parameter>, um
     ser&aacute; mostrado a cada vez que 
     <function>array_walk</function> executar
     <parameter>func</parameter>. Esses avisos podem ser suprimidos
     adicionando o operador '@' a chamada da fun&ccedil;&atilde;o <function>array_walk</function>,
     ou usando <function>error_reporting</function>.
    </simpara>
    <note>
     <para>
      Se <parameter>func</parameter> precisar alterar realmente os valores 
      do array, especifique que o primeiro par&acirc;metro de
      <parameter>func</parameter> deve ser passado por refer&ecirc;ncia. Ent&atilde;o
      qualquer mudan&ccedil;a feita nesses elementos ser&atilde;o feitas no pr&oacute;prio arra
      tamb&eacute;m.
      itself.
     </para>
    </note>
    <note>
     <para>
      A passagem das chaves e do terceiro argumento para <parameter>func</parameter> foi
      adicionada no PHP 4.0.
     </para>
     <para>
      No PHP 4 <function>reset</function> precisa ser chamada necessariamente
      uma vez que <function>array_walk</function> n&atilde;o reinicializa o array por
      padr&atilde;o.
     </para>
    </note>
    <para>
     <example>
      <title>Exemplo de <function>array_walk</function></title>
      <programlisting role="php">
<![CDATA[
$frutas = array ("d"=>"limao", "a"=>"laranja", "b"=>"banana", "c"=>"melancia");

function test_alter (&$item1, $key, $prefix) {
    $item1 = "$prefix: $item1";
}

function test_print ($item2, $key) {
    echo "$key. $item2<br>\n";
}

array_walk ($frutas, 'test_print');
reset ($frutas);
array_walk ($frutas, 'test_alter', 'fruta');
reset ($frutas);
array_walk ($frutas, 'test_print');
]]>
      </programlisting>
     </example>
    </para>
    <simpara>
     Veja tamb&eacute;m <function>each</function> e <function>list</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.arsort">
   <refnamediv>
    <refname>arsort</refname>
    <refpurpose>
     Classifica um array em ordem descrescente mantendo a associa&ccedil;&atilde;o entre os
     &iacute;ndices e os elementos
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>void</type><methodname>arsort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Essa fun&ccedil;&atilde;o classifica um array de forma que a correla&ccedil;&atilde;o entre &iacute;ndices e
     elementos &eacute; mantida. Usada principalmente para classificar arrays
     associativos onde a ordem dos elementos &eacute; um fator importante.
    </para>
    <example>
     <title>Exemplo de <function>arsort</function></title>
     <programlisting role="php">
<![CDATA[
$frutas = array ("d"=>"limao", "a"=>"laranja", "b"=>"banana", "c"=>"melancia");
arsort ($frutas);
reset ($frutas);
while (list ($chave, $valor) = each ($frutas)) {
    echo "$chave = $valor\n";
}
]]>
     </programlisting>
     <para>
      A sa&iacute;da desse exemplo seria:
      <screen>
<![CDATA[
c = melancia
d = limao
a = laranja
b = banana
]]>
      </screen>
     </para>
    </example>
    <para>
     As frutas foram classificadas na ordem alfab&eacute;tica inversa, e os &iacute;ndices
     associados a cada elemento foram mantidos.
    </para>
    <para>
     Voc&ecirc; pode modificar o comportamento da classifica&ccedil;&atilde;o usando o par&acirc;metro
     opcional <parameter>sort_flags</parameter>, para detalhes veja 
     <function>sort</function>.
    </para>
    <para>
     Veja tamb&eacute;m: <function>asort</function>, <function>rsort</function>,
     <function>ksort</function>, e <function>sort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.asort">
   <refnamediv>
    <refname>asort</refname>
    <refpurpose>
     Classifica um array mantendo a associa&ccedil;&atilde;o entre os &iacute;ndices e
     os elementos
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>void</type><methodname>asort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Essa fun&ccedil;&atilde;o classifica um array de forma que a correla&ccedil;&atilde;o entre &iacute;ndices e
     elementos &eacute; mantida.  usada principalmente para classificar arrays
     associativos onde a ordem dos elementos &eacute; um fator importante.
    </para>
    <example>
     <title>Exemplo de <function>asort</function></title>
     <programlisting role="php">
<![CDATA[
$frutas = array ("d"=>"limao", "a"=>"laranja", "b"=>"banana", "c"=>"melancia");
asort ($frutas);
reset ($frutas);
while (list ($chave, $valor) = each ($frutas)) {
    echo "$chave = $valor\n";
}
]]>
     </programlisting>
     <para>
      A sa&iacute;da desse programa seria:
      <screen>
<![CDATA[
b = banana
a = laranja
d = limao
c = melancia
]]>
      </screen>
     </para>
    </example>
    <para>
     As frutas foram classificadas na ordem alfab&eacute;tica, e os &iacute;ndices
     associados a cada elemento foram mantidos.
    </para>
    <para>
     Voc&ecirc; pode modificar o comportamento da classifica&ccedil;&atilde;o usando o par&acirc;metro
     opcional <parameter>sort_flags</parameter>, para mais detalhes
     veja <function>sort</function>.
    </para>
    <para>
     veja tamb&eacute;m <function>arsort</function>, <function>rsort</function>,
     <function>ksort</function>, e <function>sort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.compact">
   <refnamediv>
    <refname>compact</refname>
    <refpurpose>
     Cria um array contendo vari&aacute;veis e seus valores 
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>array</type><methodname>compact</methodname>
      <methodparam><type>mixed</type><parameter>varname</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>compact</function> recebe um n&uacute;mero vari&aacute;vel de
     par&acirc;metros. Cada Par&acirc;metro pode ser tanto uma string contendo o nome da
     vari&aacute;vel, como tamb&eacute;m pode ser um array de nomes de vari&aacute;veis. Sendo um
     array, ele pode conter outros arrays de nomes de vari&aacute;veis;
     <function>compact</function> os trata recursivamente.
    </para>
    <para>
     Para cada um dos par&acirc;metros passados, <function>compact</function> procura
     uma vari&aacute;vel com o nome especificado na tabela de s&iacute;mbolos e a adiciona
     no array de sa&iacute;da de forma que o nome da vari&aacute;vel ser&aacute; a chave e o seu
     conte&uacute;do ser&aacute; o valor para esta chave.
     Em resumo, ela faz o oposto de <function>extract</function>.
     Retorna um array de sa&iacute;da com todas as vari&aacute;veis adicionadas ele.
    </para>
    <para>
     Qualquer string com nome de uma vari&aacute;vel que n&atilde;o exista ser&aacute; simplesmente
     ignorada.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>compact</function></title>
      <programlisting role="php">
<![CDATA[
$cidade = "Sao Paulo";
$estado = "SP";
$evento = "SIGGRAPH";

$localidade = array ("cidade", "estado");

$result = compact ("evento", "nada_aqui", $localidade);
]]>
      </programlisting>
      <para>
       Depois disso, <varname>$result</varname> ser&aacute; <literal>array
       ("evento" =&gt; "SIGGRAPH", "cidade" =&gt; "Sao Paulo",
       "estado" =&gt; "SP")</literal>.
      </para>
     </example>
    </para>
    <para>
     Veja tamb&eacute;m <function>extract</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.count">
   <refnamediv>
    <refname>count</refname>
    <refpurpose>Conta o n&uacute;mero de elementos de uma vari&aacute;vel</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>int</type><methodname>count</methodname>
      <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
     </methodsynopsis>
    <para>
     Retorna o n&uacute;mero de elementos de <parameter>var</parameter>,
     que normalmente &eacute; um <type>array</type> (uma vez que qualquer outra coisa
     s&oacute; ter&aacute; apenas um elemento).
    </para>
    <para>
     Se <parameter>var</parameter> n&atilde;o for um array, <literal>1</literal> ser&aacute;
     retornado (excess&atilde;o: <literal>count(&null;)</literal> retorna 
     <literal>0</literal>).
    </para>
    <warning>
     <para>
      <function>count</function> pode retornar 0 para uma vari&aacute;vel
      que n&atilde;o existe, mas tamb&eacute;m pode retornar 0 para uma vari&aacute;vel que tenha
      sido inicializada como um array vazio. Use
      <function>isset</function> para checar se uma vari&aacute;vel existe.
     </para>
    </warning>
    <para>
     Por favor, veja a sess&atilde;o <link linkend="language.types.array">Arrays</link>
     do manual para uma explica&ccedil;&atilde;o mais detalhada sobre como os arrays s&atilde;o
     implementados e utilizados no PHP.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>count</function></title>
      <programlisting role="php">
      <!-- TODO: examples about count(null), count(false), count(object).. -->
<![CDATA[
$a[0] = 1; 
$a[1] = 3; 
$a[2] = 5; 
$result = count ($a);
// $result == 3

$b[0] = 7;
$b[5] = 9;
$b[10] = 11;
$result = count ($b);
// $result == 3;
]]>
      </programlisting>
     </example>
    </para>
   <note>
    <para>
     A fun&ccedil;&atilde;o <function>sizeof</function> &eacute; um apelido para
     <function>count</function>.
    </para>
   </note>
    <para>
     Veja tamb&eacute;m: <function>sizeof</function>,
     <function>isset</function>, e
     <function>is_array</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.current">
   <refnamediv>
    <refname>current</refname>
    <refpurpose>Retorna o elemento corrente em um array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>mixed</type><methodname>current</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Todo array tem um ponteiro interno para o elemento "atual",
     o qual &eacute; inicializado para apontar para o primeiro elemento inserido em
     um array.
    </para>
    <para>
     A fun&ccedil;&atilde;o <function>current</function> simplismente retorna
     o elemento do array para o qual esse ponteiro interno est&aacute; apontando.
     N&atilde;o move o ponteiro de forma alguma. Se o ponteiro interno
     estiver apontando para al&eacute;m do final da lista de elementos,
     <function>current</function> retorna &false;.
     <warning>
      <para> 
       Se o array cont&ecirc;m elementos vazios (0 ou "", a
       string vazia) ent&atilde;o esta fun&ccedil;&atilde;o retorna &false; 
       para esses elementos. Isso faz com que seja imposs&iacute;vel 
       determinar se voc&ecirc; est&aacute; realmente no final da lista de elementos de
       array usando <function>current</function>.  Para percorrer 
       devidamente um array que pode conter elementos vazios, use a fun&ccedil;&atilde;o
       <function>each</function>.  
      </para>
     </warning>
    </para>
    <para>
     Veja tamb&eacute;m: <function>end</function>, <function>next</function>,
     <function>prev</function>, e <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.each">
   <refnamediv>
    <refname>each</refname> 
    <refpurpose>
     Retorna o par chave/valor corrente de um array e avan&ccedil;a o seu cursor
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>array</type><methodname>each</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Retorna o par chave/valor corrente de
     <parameter>array</parameter> e avan&ccedil;a o seu cursor. Esse
     par &eacute; retornado num array de quatro elementos, com as chaves
     <emphasis>0</emphasis>, <emphasis>1</emphasis>,
     <emphasis>key</emphasis>, e
     <emphasis>value</emphasis>. Os elementos <emphasis>0</emphasis> e
     <emphasis>key</emphasis> cont&ecirc;m o nome da chave do elemento do array, e
     <emphasis>1</emphasis> e <emphasis>value</emphasis> cont&ecirc;m o valor.
    </para>
    <para>
     Se o cursor interno do array estiver apontando para al&eacute;m do final do
     array, <function>each</function> retorna &false;.
    </para>
    <para>
     <example>
      <title>Exemplos de <function>each</function></title>
      <programlisting role="php">
<![CDATA[
$foo = array ("bob", "fred", "jussi", "jouni", "egon", "marliese");
$bar = each ($foo);
]]>
      </programlisting>
      <para>
       <varname>$bar</varname> agora contem os seguintes pares de chaves e
       valores:
       <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">
<![CDATA[
$foo = array ("Robert" => "Bob", "Seppo" => "Sepi");
$bar = each ($foo);
]]>
       </programlisting>
      </para>
      <para>
       <varname>$bar</varname> agora contem os seguintes pares de chaves e
       valores:
       <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> &eacute; tipicamente usada em conjunto com
     <function>list</function> para percorrer o array; por exemplo,
     <varname>$HTTP_POST_VARS</varname>: 
     <example>
      <title>
       Percorrendo <varname>$HTTP_POST_VARS</varname> usando
       <function>each</function>
      </title>
      <programlisting role="php">
<![CDATA[
echo "Valores submetidos pelo m&eacute;todo POST:<br>";
reset ($HTTP_POST_VARS);
while (list ($chave, $valor) = each ($HTTP_POST_VARS)) {
    echo "$chave => $valor<br>";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Depois da execu&ccedil;&atilde;o de <function>each</function>, o cursor interno do
     array vai apontar para o pr&oacute;cimo elemento do array, ou no &uacute;ltimo
     elemento se ele chegar ao final do array. Voc&ecirc; deve usar 
     <function>reset</function> se quiser percorrer o array novamente.
    </para>
    <para>
     Veja tamb&eacute;m <function>key</function>, <function>list</function>,
     <function>current</function>, <function>reset</function>,
     <function>next</function>, e <function>prev</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.end">
   <refnamediv>
    <refname>end</refname>
    <refpurpose>
     Faz com que o ponteiro interno de um array aponte para o seu &uacute;ltimo
     elemento
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>mixed</type><methodname>end</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>end</function> avan&ccedil;a o ponteiro interno de <parameter>array</parameter>
     at&eacute; o seu &uacute;ltimo elemento, e retorna esse elemento.
    </para>
    <para>
     Veja tamb&eacute;m: <function>current</function>,
     <function>each</function>, <function>end</function>,
     <function>next</function>, e <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.extract">
   <refnamediv>
    <refname>extract</refname>
    <refpurpose>
     Importa vari&aacute;veis para a tabela de s&iacute;mbolos a partir de um array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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>
     Essa &eacute; usada para importar vari&aacute;veis a partir de um array para a tabela
     de s&iacute;mbolos corrente. Recebe o array associativo
     <parameter>var_array</parameter> e trata as suas chaves como
     os nomes das vari&aacute;veis e os valores como valores das vari&aacute;veis. 
     Para cada par chave/valor ele criar&aacute; uma vari&aacute;vel na tabela de s&iacute;mbolos
     corrente, seguindo os par&acirc;metros
     <parameter>extract_type</parameter> e
     <parameter>prefix</parameter>.
    </para>
    <note>
     <para>
      Desde a vers&atilde;o 4.0.5 essa fun&ccedil;&atilde;o retorna o n&uacute;mero de vari&aacute;veis
      extra&iacute;das.
     </para>
    </note>
    <para>
     <function>extract</function> checa se cada chave do array constituinum
     nome de vari&aacute;vel v&aacute;lido e por colis&otilde;es com as vari&aacute;veis j&aacute; existentes na
     tabela de s&iacute;mbolos. O modo com que chaves inv&aacute;lidas ou n&uacute;mericas e colis&otilde;es 
     s&atilde;o tratadas &eacute; determinado pelo argumento 
     <parameter>extract_type</parameter>. Esse argumento pode receber os
     seguintes valores:
     <variablelist>
      <varlistentry>
       <term>EXTR_OVERWRITE</term>
       <listitem>
        <simpara>
         Se houver uma colis&atilde;o, sobrescreve a vari&aacute;vel existente.
        </simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_SKIP</term>
       <listitem>
        <simpara>
         Se houver uma colis&atilde;o, n&atilde;o sobrescreve a vari&aacute;vel existente.
        </simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_PREFIX_SAME</term>
       <listitem>
        <simpara>Se houver uma colis&atilde;o, adiciona um prefixo ao nome da
        vari&aacute;vel definido pelo argumento 
        <parameter>prefix</parameter>.
        </simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_PREFIX_ALL</term>
       <listitem>
        <simpara>
         Adiciona um prefixo ao nome de todas as vari&aacute;veis definido por 
         <parameter>prefix</parameter>. Desde o PHP 4.0.5 est&atilde;o inclu&iacute;dos
         nomes num&eacute;ricos.
        </simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_PREFIX_INVALID</term>
       <listitem>
        <simpara>
         Adiciona um prefixo definido por <parameter>prefix</parameter> apenas
         para vari&aacute;veis como nomes inv&aacute;lidos ou num&eacute;ricos. Essa op&ccedil;&atilde;o foi adicionada no
         PHP 4.0.5.
        </simpara>
       </listitem>
      </varlistentry>
     </variablelist>
    </para>
    <para>
     Se <parameter>extract_type</parameter> n&atilde;o for especificado, &eacute; assumido
     o valor EXTR_OVERWRITE por padr&atilde;o.
    </para>
    <para>
     Note que <parameter>prefix</parameter> s&oacute; &eacute; necess&aacute;rio se
     <parameter>extract_type</parameter> for EXTR_PREFIX_SAME,
     EXTR_PREFIX_ALL, ou EXTR_PREFIX_INVALID. se o nome com o prefixo
     n&atilde;o for um nome de vari&aacute;vel v&aacute;lido, ela n&atilde;o ser&aacute; importada para a tabela
     de s&iacute;mbolos.
    </para>
    <para>
     <function>extract</function> retorna o n&uacute;mero de vari&aacute;veis importadas
     com sucesso para a tbela de s&iacute;mbolos.
    </para>
    <para>
     Um uso comum de extract e na importa&ccedil;&atilde;o de
     vari&aacute;veis contidas num array associativo retornado pela fun&ccedil;&atilde;o
     <function>wddx_deserialize</function>.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>extract</function></title>
      <programlisting role="php">
<![CDATA[
<?php

/* Suponha que $var_array &eacute; um array retornado pela fun&ccedil;&atilde;o
   wddx_deserialize */

$tamanho = "grande";
$var_array = array ("cor" => "azul",
                    "tamanho"  => "medio",
                    "forma" => "esfera");
extract ($var_array, EXTR_PREFIX_SAME, "wddx");

print "$cor, $tamanho, $forma, $wddx_tamanho\n";

?>
]]>
      </programlisting>
     </example>
    </para>
    <para>
     O exemplo acima produziria:
     <programlisting>
<![CDATA[
azul, grande, esfera, medio
]]>
     </programlisting>
    </para>
    <para>
     O <varname>$tamanho</varname> n&atilde;o foi sobrescrito, porque
     n&oacute;s especificamos EXTR_PREFIX_SAME, o que resultou na cria&ccedil;&atilde;o da vari&aacute;vel 
     <varname>$wddx_tamanho</varname>.  Se EXTR_SKIP fosse
     utilizado, ent&atilde;o $wddx_tamanho n&atilde;o seria criada.
     EXTR_OVERWRITE teria feito com que <varname>$size</varname> tivesse
     o valor "medio", e EXTR_PREFIX_ALL resultaria em novas vari&aacute;veis
     com os nomes <varname>$wddx_cor</varname>,
     <varname>$wddx_tamanho</varname>, e
     <varname>$wddx_forma</varname>.
    </para>
    <para>
     Voc&ecirc; deve usar um arra associativo, um array indexado numericamente n&atilde;o
     produzir&aacute; resultados.
    </para>
    <para>
     Veja tamb&eacute;m: <function>compact</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.in-array">
   <refnamediv>
    <refname>in_array</refname>
    <refpurpose>Retorna &true; se um valor existe no array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>bool</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>bool</type><parameter>strict</parameter></methodparam>
     </methodsynopsis>
    <para>
     Procura em <parameter>haystack</parameter> pelo valor
     <parameter>needle</parameter> e retorna &true; 
     se este valor for encontrado no array, e &false; em caso contr&aacute;rio.
    </para>
    <para>
     Se o terceiro par&acirc;metro <parameter>strict</parameter> for
     &true; ent&atilde;o <function>in_array</function>
     tamb&eacute;m ir&aacute; checar os <link linkend="language.types">tipos</link> de
     <parameter>needle</parameter> em <parameter>haystack</parameter>.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>in_array</function></title>
      <programlisting role="php">
<![CDATA[
$os = array ("Mac", "NT", "Irix", "Linux");
if (in_array ("Irix", $os)) {
    print "Tem Irix";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     <example>
      <title><function>in_array</function> com checagem de tipos</title>
      <programlisting role="php">
<![CDATA[
<?php
$a = array('1.10', 12.4, 1.13);

if (in_array('12.4', $a, TRUE))
    echo "'12.4' encontrado com checagem de tipo\n";
if (in_array(1.13, $a, TRUE))
    echo "1.13 encontrado com checagem de tipo\n";
?>

// Isso ir&aacute; produzir:

1.13 encontrado com checagem de tipo
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Veja tamb&eacute;m <function>array_search</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-search">
   <refnamediv>
    <refname>array_search</refname>
    <refpurpose>
     Procura por um valor em um array e retorna sua chave correspondente 
     caso seja encontrado
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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 choice="opt"><type>bool</type><parameter>strict</parameter></methodparam>
     </methodsynopsis>
    <para>
     Procura em <parameter>haystack</parameter> pelo valor 
     <parameter>needle</parameter> e retorna sua chave se for encontrado no
     array, &false; em caso contr&aacute;rio.
    </para>
    <para>
     se o terceiro par&acirc;metro opcional <parameter>strict</parameter> for
     fornecido como &true; ent&atilde;o <function>array_search</function>
     tamb&eacute;m far&aacute; uma checagem de tipos de <parameter>needle</parameter>
     em <parameter>haystack</parameter>.
    </para>
    <para>
     Veja tamb&eacute;m <function>in_array</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.key">
   <refnamediv>
    <refname>key</refname>
    <refpurpose>Retorna uma chave de um array associativo</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>mixed</type><methodname>key</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>key</function> retorna a chave da posi&ccedil;&atilde;o corrente de um
     array.
    </para>
    <para>
     Veja tamb&eacute;m <function>current</function> e <function>next</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.krsort">
   <refnamediv>
    <refname>krsort</refname>
    <refpurpose>Classifica um array pelas chaves em ordem descrescente</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>int</type><methodname>krsort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Classifica um array pelas chaves em ordem descrescente, mantendo a
     correla&ccedil;&atilde;o entre entre as chaves e os valores. Essa fun&ccedil;&atilde;o &eacute; bastante
     &uacute;til em arrays associativos.
     <example>
      <title>Exemplo de <function>krsort</function></title>
      <programlisting role="php">
<![CDATA[
$frutas = array ("d"=>"limao", "a"=>"laranja", "b"=>"banana", "c"=>"melancia");
krsort ($frutas);
reset ($frutas);
while (list ($chave, $valor) = each ($frutas)) {
    echo "$chave = $valor\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     A sa&iacute;da deste programa seria:
    </para>
    <para>
     <informalexample>
      <programlisting>
<![CDATA[
d = limao
c = melancia
b = banana
a = laranja
]]>
      </programlisting>
     </informalexample>
    </para>
    <para>
     Voc&ecirc; pode alterar o comportamento da classifica&ccedil;&atilde;o utilizando o
     par&acirc;metro opcional <parameter>sort_flags</parameter>, para mais detalhes 
     veja <function>sort</function>.
    </para>
    <simpara>
     Veja tamb&eacute;m <function>asort</function>, <function>arsort</function>,
     <function>ksort</function> <function>sort</function>, 
     <function>natsort</function> e <function>rsort</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.ksort">
   <refnamediv>
    <refname>ksort</refname>
    <refpurpose>Classifica um array pelas chaves</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>int</type><methodname>ksort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Classifica um array pelas chaves, mantendo a correla&ccedil;&atilde;o entre as chaves e 
     os valores. Essa fun&ccedil;&atilde;o &eacute; bastante &uacute;til principalmente em arrays
     associativos.
     <example>
      <title>Exemplo de <function>ksort</function></title>
      <programlisting role="php">
<![CDATA[
$frutas = array ("d"=>"limao", "a"=>"laranja", "b"=>"banana", "c"=>"melancia");
ksort ($frutas);
reset ($frutas);
while (list ($chave, $valor) = each ($frutas)) {
    echo "$chave = $valor\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     O programa acima mostraria:
    </para>
    <para>
     <informalexample>
      <programlisting>
<![CDATA[
a = laranja
b = banana
c = melancia
d = limao
]]>
      </programlisting>
     </informalexample>     
    </para>
    <para>
     Voc&ecirc; pode modificar o comportamento da classifica&ccedil;&atilde;o atrav&eacute;s do par&acirc;metro
     opcional <parameter>sort_flags</parameter>, para mais detalhes
     veja <function>sort</function>.
    </para>
    <simpara>
     Veja tamb&eacute;m <function>asort</function>, <function>arsort</function>, 
     <function>sort</function>, <function>natsort</function>, e 
     <function>rsort</function>.
    </simpara>
    <note>
     <para>
      O segundo par&acirc;metro foi adicionado a partir do PHP 4.
     </para>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.list">
   <refnamediv>
    <refname>list</refname>
    <refpurpose>
     Cria vari&aacute;veis como se fossem arrays
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>void</type><methodname>list</methodname>
      <methodparam rep="repeat"><type>mixed</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     Assim como <function>array</function>, n&atilde;o &eacute; exatamente uma fun&ccedil;&atilde;o,
     e sim uma estrutura da pr&oacute;pria linguagem.  <function>list</function> &eacute; usada
     para criar uma lista de vari&aacute;veis em apenas um opera&ccedil;&atilde;o.
     <example>
      <title>Exemplo de <function>list</function></title>
      <programlisting role="php">
<![CDATA[
<table>
 <tr>
  <th>Nome do empregado</th>
  <th>Sal&aacute;rio</th>
 </tr>

<?php

$resultado = mysql_query ("SELECT id, nome, salario FROM empregados",$conn);
while (list ($id, $nome, $salario) = mysql_fetch_row ($resultado)) {
    print (" <tr>\n".
           "  <td><a href=\"info.php3?id=$id\">$nome</a></td>\n".
           "  <td>$salario</td>\n".
           " </tr>\n");
}

?>

</table>
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Veja tamb&eacute;m <function>each</function> e <function>array</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.natsort">
   <refnamediv>
    <refname>natsort</refname>
    <refpurpose>
     Classifica um array utlizando o algoritmo da "ordem natural"
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>void</type><methodname>natsort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Essa fun&ccedil;&atilde;o &eacute; um implementa&ccedil;&atilde;o do algoritmo que ordena
     strings alfanum&eacute;ricas da forma como um ser humano faria.  Isso &eacute;
     chamado de "ordena&ccedil;&atilde;o natural". Um exemplo da diferen&ccedil;a entre
     esse algoritmo e o algoritmo com o qual o computador classifica strings
     (usado em <function>sort</function>) pode ser visto abaixo:
    </para>
    <para>
     <example>
      <title>Exemplo de <function>natsort</function></title>
      <programlisting role="php">
<![CDATA[
$array1 = $array2 = array ("img12.png", "img10.png", "img2.png", "img1.png");
 
sort($array1);
echo "Classifica&ccedil;&atilde;o normal\n";
print_r($array1);

natsort($array2);
echo "\nClassifica&ccedil;&atilde;o da \"ordem natural\"\n";
print_r($array2);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     O c&oacute;digo acima geraria a seguinte sa&iacute;da:
    </para>
    <para>
     <informalexample>
      <programlisting>
<![CDATA[
Classifica&ccedil;&atilde;o normal
Array
(
    [0] => img1.png
    [1] => img10.png
    [2] => img12.png
    [3] => img2.png
)

Classifica&ccedil;&atilde;o da "ordem natural"
Array
(
    [3] => img1.png
    [2] => img2.png
    [1] => img10.png
    [0] => img12.png
)
]]>
      </programlisting>
     </informalexample>
     Para mais informa&ccedil;&otilde;es veja: Martin Pool's <ulink
     url="&url.strnatcmp;">Natural Order String Comparison</ulink>
     page.
    </para>
    <para>
     Veja tamb&eacute;m <function>natcasesort</function>,
     <function>strnatcmp</function> e
     <function>strnatcasecmp</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.natcasesort">
   <refnamediv>
    <refname>natcasesort</refname>
    <refpurpose>
     Classifica um array utilizando o algoritmo da "ordem natural" sem
     diferenciar mai&uacute;sculas e min&uacute;sculas
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>void</type><methodname>natcasesort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Essa fun&ccedil;&atilde;o implementa o algoritmo de classifica&ccedil;&atilde;o que ordena
     strings alfanum&eacute;ricas da forma que os humanas fariam. Essa forma de
     classifica&ccedil;&atilde;o &eacute; denominada "ordena&ccedil;&atilde;o natural".
    </para>
    <para>
     <function>natcasesort</function> &eacute; uma vers&atilde;o de 
     <function>natsort</function> que n&atilde;o diferencia letras mai&uacute;sculas e
     min&uacute;sculas. Veja <function>natsort</function>
     para saber a diferen&ccedil;a entrre esse algoritmo e os algoritmos
     utlizados normalmente para ordena&ccedil;&atilde;o de strings.
    </para>
    <para>
     Para mais informa&ccedil;&otilde;es veja: Martin Pool's <ulink
     url="&url.strnatcmp;">Natural Order String Comparison</ulink>
     page.
    </para>
    <para>
     Veja tamb&eacute;m <function>sort</function>,
     <function>natsort</function>,
     <function>strnatcmp</function> e
     <function>strnatcasecmp</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.next">
   <refnamediv>
    <refname>next</refname>
    <refpurpose>
     Avan&ccedil;a o ponteiro interno de um array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>mixed</type><methodname>next</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Retorna o elemento do array que est&aacute; na pr&oacute;xima posi&ccedil;&atilde;o que &eacute; apontada
     pelo ponteiro interno do array, &false; caso n&atilde;o existam mais elementos.
    </para>
    <para>
     <function>next</function> funciona de forma semelhante a 
     <function>current</function>, com uma diferen&ccedil;a. Ele avan&ccedil;a o 
     ponteiro interno do array em uma posi&ccedil;&atilde;o antes de retornar o
     elemento. Isso significa que ela retorna o pr&oacute;ximo elemento do array 
     avan&ccedil;ando o ponteiro interno em uma posi&ccedil;&atilde;o. Se o ponteiro
     interno apontar para al&eacute;m do final da lista de elementos
     , <function>next</function> retorna &false;.
     <warning>
      <para>
       Se o array contiver elementos vazios, ou elementos tiverem chaves
       com 0 como valor ent&atilde;o essa fun&ccedil;&atilde;o retorna &false; 
       para esses elementos. Para percorrer um array que  
       pode conter elementos vazios ou elementos que tenham chaves com 0 como valor 
       veja a fun&ccedil;&atilde;o <function>each</function>.
      </para>
     </warning>
    </para>
    <para>
     Veja tamb&eacute;m:
     <function>current</function>, <function>end</function>,
     <function>prev</function>, e <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.pos">
   <refnamediv>
    <refname>pos</refname>
    <refpurpose>Retorna o elemento atual do array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>mixed</type><methodname>pos</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <simpara>
     Essa fun&ccedil;&atilde;o &eacute; igual a <function>current</function>.
    </simpara>
    <para>
     See also:
     <function>end</function>, <function>next</function>,
     <function>prev</function> e <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.prev">
   <refnamediv>
    <refname>prev</refname>
    <refpurpose>Retrocede o ponteiro interno de um array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>mixed</type><methodname>prev</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Retorna o elemento do array que est&aacute; na posi&ccedil;&atilde;o anterior a posi&ccedil;&atilde;o apontada
     pelo ponteiro interno, ou &false; se houver mais elementos.
     <warning>
      <para>
       Se o array contiver elementos vazios ent&atilde;o essa fun&ccedil;&atilde;o retornar&aacute;
       &false; para esses elementos. 
       Para percorrer corretamente arrays que podem conter elementos vazios
       veja a fun&ccedil;&atilde;o <function>each</function>.
      </para>
     </warning>
    </para>
    <para>  
     <function>prev</function> funciona da mesma forma que 
     <function>next</function>, com a &uacute;nica sendo a de que a primeira
     retrocede o ponteiro interno em uma posi&ccedil;&atilde;o ao inv&eacute;s de avan&ccedil;&aacute;-lo.
    </para>
    <para>
     Veja tamb&eacute;m: <function>current</function>, <function>end</function>,
     <function>next</function>, e <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.range">
   <refnamediv>
    <refname>range</refname>
    <refpurpose>
     Cria um array contendo uma faixa de elementos 
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>array</type><methodname>range</methodname>
      <methodparam><type>mixed</type><parameter>low</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>high</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>range</function> retorna um array com elementos de
     <parameter>low</parameter> at&eacute; <parameter>high</parameter>,
     com intervalo fechado.  Se low > high, ser&aacute; de high at&eacute; low.
     <example>
      <title>Exemplos de <function>range</function></title>
      <programlisting role="php">
<![CDATA[
foreach(range(0, 9) as $numero) {
    echo $numero;
}
foreach(range('a', 'z') as $letra) {
    echo $letra;
}
foreach(range('z', 'a') as $letra) {
    echo $letra;
}
]]>
      </programlisting>
     </example>
    </para>
    <note>
     <para>
      At&eacute; a vers&atilde;o 4.1.0, a fun&ccedil;&atilde;o <function>range</function> s&oacute; gerava
      arrays de inteiros em ordem crescente. O suporte para
      sequ&ecirc;ncias de caracteres e arrays descrescentes foi adicionado no PHP 4.1.0.
     </para>
    </note>
    <para>
     Veja <function>shuffle</function> para outro exemplo de utiliza&ccedil;&atilde;o dessa
     fun&ccedil;&atilde;o.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.reset">
   <refnamediv>
    <refname>reset</refname>
    <refpurpose>
     Faz o ponteiro interno de um array apontar para o seu primeiro elemento
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>mixed</type><methodname>reset</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>reset</function> retrocede o ponteiro interno de <parameter>array</parameter>
     para o primeiro elemento.
    </para>
    <para>
     <function>reset</function> retorna o valor do primeiro elemento do array.
    </para>
    <para>
     Veja tamb&eacute;m: <function>current</function>,
     <function>each</function>, <function>next</function>,
     e <function>prev</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.rsort">
   <refnamediv>
    <refname>rsort</refname>
    <refpurpose>Classifica um array em ordem descrescente</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>void</type><methodname>rsort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     essa fun&ccedil;&atilde;o classifica um array para a ordem descrescente (do maior para o menor).
     <example>
      <title>Exemplo de <function>rsort</function></title>
      <programlisting role="php">
<![CDATA[
$frutas = array ("limao", "laranja", "banana", "melancia");
rsort ($frutas);
reset ($frutas);
while (list ($chave, $valor) = each ($frutas)) {
    echo "$chave = $valor\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Esse exemplo mostraria:
    </para>
    <para>
     <informalexample>
      <programlisting>
<![CDATA[
0 = melancia
1 = limao
2 = laranja
3 = banana
]]>
      </programlisting>
     </informalexample>
    </para>
    <para>
     As frutas foram classificadas em ordem alfab&eacute;tica decrescente.
    </para>
    <para>
     Voc&ecirc; pode alterar o comportamento da classifica&ccedil;&atilde;o utilizando o par&acirc;metro
     opcional <parameter>sort_flags</parameter>, para mais detalhes 
     veja <function>sort</function>.
    </para>
    <para>
     Veja tamb&eacute;m: <function>arsort</function>,
     <function>asort</function>, <function>ksort</function>,
     <function>sort</function>, e <function>usort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.shuffle">
   <refnamediv>
    <refname>shuffle</refname>
    <refpurpose>Mistura os elementos de um array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>void</type><methodname>shuffle</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Essa fun&ccedil;&atilde;o mistura de forma aleat&oacute;ria os elementos de um
     array. Voc&ecirc; deve usar essa fun&ccedil;&atilde;o em conjunto com <function>srand</function>.
     <example>
      <title>Exemplo de <function>shuffle</function></title>
      <programlisting role="php">
<![CDATA[
$numeros = range (1,20);
srand ((float)microtime()*1000000);
shuffle ($numeros);
while (list (, $numero) = each ($numeros)) {
    echo "$numero ";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Veja tamb&eacute;m <function>arsort</function>, <function>asort</function>,
     <function>ksort</function>, <function>rsort</function>,
     <function>sort</function> e <function>usort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.sizeof">
   <refnamediv>
    <refname>sizeof</refname>
    <refpurpose>Retorna o n&uacute;mero de elementos de uma vari&aacute;vel</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>int</type><methodname>sizeof</methodname>
      <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>sizeof</function> &eacute; igual a 
     <function>count</function>.
    </para>
    <para>
     Veja tamb&eacute;m <function>count</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.sort">
   <refnamediv>
    <refname>sort</refname>
    <refpurpose>Classifica um array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>void</type><methodname>sort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Essa fun&ccedil;&atilde;o classifica um array. Os elementos ser&atilde;o ordenador
     do menor para o maior ao final da execu&ccedil;&atilde;o dessa fun&ccedil;&atilde;o.
     <example>
      <title>Exemplo de <function>sort</function></title>
      <programlisting role="php">
<![CDATA[
<?php

$frutas = array ("limao", "laranja", "banana", "melancia");
sort ($frutas);
reset ($frutas);
while (list ($chave, $valor) = each ($frutas)) {
    echo "frutas[".$chave."] = ".$valor."\n";
}
 
?>
]]>
      </programlisting>
     </example>
    </para>
    <para>
     A sa&iacute;da desse programa seria:
    </para>
    <para>
     <informalexample>
      <programlisting>
<![CDATA[
fruits[0] = banana
fruits[1] = laranja
fruits[2] = limao
fruits[3] = melancia
]]>
      </programlisting>
     </informalexample>
    </para>
    <para>
     As frutas foram classificadas em ordem alfab&eacute;tica.
    </para>
    <para>
     O segundo argumento opcional <parameter>sort_flags</parameter>
     pode ser usada para modificar o comportamento da classifica&ccedil;&atilde;o podendo
     receber os seguintes valores:
    </para>
    <para>
     Sinais de tipo de classifica&ccedil;&atilde;o:
     <itemizedlist>
      <listitem>
       <simpara>SORT_REGULAR - compara os itens normalmente</simpara>
      </listitem>
      <listitem>
       <simpara>SORT_NUMERIC - compara os itens como valores num&eacute;ricos</simpara>
      </listitem>
      <listitem>
       <simpara>SORT_STRING - compara os itens como strings</simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para>
     Veja tamb&eacute;m: <function>arsort</function>,
     <function>asort</function>, <function>ksort</function>,
     <function>natsort</function>, <function>natcasesort</function>,
     <function>rsort</function>, <function>usort</function>,
     <function>array_multisort</function>, e
     <function>uksort</function>.
    </para>
    <note>
     <para>
      O segundo par&acirc;metro foi adicionado a partir do PHP 4.
     </para>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.uasort">
   <refnamediv>
    <refname>uasort</refname>
    <refpurpose>
     Classifica um array utlizando uma fun&ccedil;&atilde;o de compara&ccedil;&atilde;o definida pelo usu&aacute;rio e mantendo
     as associa&ccedil;&otilde;es dos &iacute;ndices
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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>
     Essa fun&ccedil;&atilde;o classifica um array de forma que a correla&ccedil;&atilde;o entre os
     &iacute;ndices e os elementos com que est&atilde;o associados. Essa fun&ccedil;&atilde;o usada
     principalmente para classificar arrays associativos onde a ordem dos
     elementos &eacute; um fator importante. A fun&ccedil;&atilde;o de comparac&atilde;o &eacute; definida pelo
     usu&aacute;rio.
    </para>
    <note>
     <para>
      Por favor, veja <function>usort</function> e
      <function>uksort</function> para exemplos de fun&ccedil;&otilde;es de compara&ccedil;&atilde;o definidas pelo
      usu&aacute;rio.
     </para>
    </note>
    <para>
     Veja tamb&eacute;m: <function>usort</function>, <function>uksort</function>, 
     <function>sort</function>, <function>asort</function>, 
     <function>arsort</function>, <function>ksort</function> 
     e <function>rsort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.uksort">
   <refnamediv>
    <refname>uksort</refname>
    <refpurpose>
     Classifica um array pelas chaves utilizando uma fun&ccedil;&atilde;o de compara&ccedil;&atilde;o
     definida pelo usu&aacute;rio.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</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>
     Essa fun&ccedil;&atilde;o ia classificar as chaves de um array usando uma fun&ccedil;&atilde;o de
     compara&ccedil;&atilde;o definida pelo usu&aacute;rio. Se o array 
     precisa ser classificado utilizando um crit&eacute;rio n&atilde;o trivial, voc&ecirc; deve
     usar essa fun&ccedil;&atilde;o.
    </para>
    <para>
     <example>
      <title>Exemplo de <function>uksort</function></title>
      <programlisting role="php">
<![CDATA[
function cmp ($a, $b) {   
    if ($a == $b) return 0;
    return ($a > $b) ? -1 : 1;
}

$a = array (4 => "quatro", 3 => "tres", 20 => "vinte", 10 => "dez");

uksort ($a, "cmp");

while (list ($chave, $valor) = each ($a)) {
    echo "$chave: $valor\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Esse exemplo mostraria:
    </para>
    <para>
     <informalexample>
      <programlisting>
<![CDATA[
20: vinte
10: dez
4: quatro
3: tres
]]>
      </programlisting>
     </informalexample>
    </para>
    <para>
     Veja tamb&eacute;m: <function>usort</function>, <function>uasort</function>, 
     <function>sort</function>, <function>asort</function>, 
     <function>arsort</function>, <function>ksort</function>,
     <function>natsort</function> e <function>rsort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.usort">
   <refnamediv>
    <refname>usort</refname>
    <refpurpose>
     Classifica um array pelos valores utilizando uma fun&ccedil;&atilde;o de compara&ccedil;&atilde;o
     definida pelo usu&aacute;rio 
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descri&ccedil;&atilde;o</title>
     <methodsynopsis>
      <type>void</type><methodname>usort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam><type>string</type><parameter>cmp_function</parameter></methodparam>
     </methodsynopsis>
    <para>
     Essa fun&ccedil;&atilde;o ir&aacute; classificar um array pelos valores usando uma fun&ccedil;&atilde;o de
     classifica&ccedil;&atilde;o definida pelo usu&aacute;rio. Se o array precisar ser classificado
     utilizando um crit&eacute;rio n&atilde;o trivial, voc&ecirc; deve usar essa fun&ccedil;&atilde;o.
    </para>
    <para>
     A fun&ccedil;&atilde;o de compara&ccedil;&atilde;o deve retornar um inteiro menor, igual ou maior que
     zero se o primeiro argumento for considerado respectivamente menor,
     igual, ou maior que o segundo. Se dois elementos forem iguais, a ordem
     deles ser&aacute; indefinida.
    </para>
    <para>
     Tamb&eacute;m &eacute; poss&iacute;vel utilizar uma fun&ccedil;&atilde;o membro de um objeto como a fun&ccedil;&atilde;o
     de compara&ccedil;&atilde;o. Veja o exemplo 3 abaixo:
    </para>
    <para>
     <example>
      <title>Exemplo de <function>usort</function></title>
      <programlisting role="php">
<![CDATA[
function cmp ($a, $b) {   
    if ($a == $b) return 0;
    return ($a > $b) ? -1 : 1;
}

$a = array (3, 2, 5, 6, 1);

usort ($a, "cmp");

while (list ($chave, $valor) = each ($a)) {
    echo "$chave: $valor\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Esse exemplo mostraria:
    </para>
    <para>
     <informalexample>
      <programlisting>
<![CDATA[
0: 6
1: 5
2: 3
3: 2
4: 1
]]>
      </programlisting>
     </informalexample>
    </para>
    <note>
     <para>
      Obviamente que nesse caso trivial a fun&ccedil;&atilde;o<function>rsort</function>
      seria mais apropriada.
     </para>
    </note>
    <para>
     <example>
      <title>
       Exemplo de <function>usort</function> usando um array multi-dimensional
      </title>
      <programlisting role="php">
<![CDATA[
function cmp ($a, $b) {
    return strcmp($a["fruta"], $b["fruta"]);
} 

$frutas[0]["fruta"] = "limoes";
$frutas[1]["fruta"] = "abacaxis";
$frutas[2]["fruta"] = "goiabas";

usort($frutas, "cmp"); 

while (list ($chave, $valor) = each ($frutas)) {
    echo "\$frutas[$chave]: " . $valor["fruta"] . "\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Na classifica&ccedil;&atilde;o de um array multi-dimensional, $a e $b cont&ecirc;m
     refer&ecirc;ncias para o primeiro &iacute;ndice do array.
    </para>
    <para>
     Esse exemplo mostraria:
    </para>
    <para>
     <informalexample>
      <programlisting>
<![CDATA[
$fruits[0]: abacaxis
$fruits[1]: goiabas
$fruits[2]: limoes
]]>
      </programlisting>
     </informalexample>
    </para>

    <para>
     <example>
      <title>
       Exemplo de <function>usort</function> usando uma fun&ccedil;&atilde;o membro de um
       objeto 
      </title>
      <programlisting role="php">
class TestObj {
    var $name;

    function TestObj($name)
    {
        $this->name = $name;
    }

    /* Essa &eacute; a fun&ccedil;&atilde;o est&aacute;tica de compara&ccedil;&atilde;o */
    function cmp_obj($a, $b)
    {
        $al = strtolower($a->name);
        $bl = strtolower($b->name);
        if ($al == $bl) return 0;
        return ($al > $bl) ? +1 : -1;
    }
}

$a[] = new TestObj("c");
$a[] = new TestObj("b");
$a[] = new TestObj("d");

uasort($a, array ("TestObj", "cmp_obj"));

foreach ($a as $item) {
    print $item->name."\n";
}
      </programlisting>
     </example>
    </para>
    <para>
     Esse exemplo mostraria:
    </para>
    <para>
     <informalexample>
      <programlisting>
b
c
d
      </programlisting>
     </informalexample>
    </para>
    <para>
     <warning>
      <para>
       
      </para>
     </warning>
    </para>
    <para>
     Veja tamb&eacute;m: <function>uasort</function>,
     <function>uksort</function>, <function>sort</function>,
     <function>asort</function>,
     <function>arsort</function>,<function>ksort</function>,
     <function>natsort</function>, e <function>rsort</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
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->