<?xml version="1.0" encoding="iso-8859-1"?>
 <reference id="ref.array">
  <title>Funciones de matrices</title>
  <titleabbrev>Matrices</titleabbrev>

  <refentry id="function.array">
   <refnamediv>
    <refname>array</refname>
    <refpurpose>
     Crear una matriz
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>array</methodname>
     <methodparam rep="repeat"><type>mixed</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     Devuelve una matriz con los par&aacute;metros que se le pasan. A dichos 
     par&aacute;metros se les puede dar un &iacute;ndice usando el operador <literal>=&gt;</literal>.
     <note>
      <para>
       <function>array</function> es una construcci&oacute;n del lenguaje que se 
       utiliza para representar matrices literales, no una funci&oacute;n regular.
      </para>
     </note>
    </para>
    <para>
     El siguiente ejemplo demuestra c&oacute;mo crear una matriz 
     bidimensional, c&oacute;mo especificar claves para matrices
     asociativas, y c&oacute;mo especificar &iacute;ndices no consecutivos
     en matrices normales.
     <example>
      <title>Ejemplo de <function>array</function></title>
      <programlisting role="php">
$frutas = array (
    "frutas"  => array("a"=>"naranja", "b"=>"pl&aacute;tano", "c"=>"manzana"),
    "n&uacute;meros" => array(1, 2, 3, 4, 5, 6),
    "hoyos"   => array("primero", 5 => "segundo", "tercero")
);
      </programlisting>
     </example>
    </para>
    <para>
     Vea tambi&eacute;n: <function>list</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-count-values">
   <refnamediv>
    <refname>array_count_values</refname>
    <refpurpose>Cuenta todos los valores de una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>array_count_values</methodname>
     <methodparam><type>array</type><parameter>entrada</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_count_values</function> devuelve una matriz usando 
     los valores de la matriz <parameter>entrada</parameter> como claves y
     su frecuencia de aparici&oacute;n en la <parameter>entrada</parameter> como valores.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_count_values</function></title>
      <programlisting role="php">
$matriz = array(1, "hola", 1, "mundo", "hola");
array_count_values($matriz); // devuelve array(1=>2, "hola"=>2, "mundo"=>1)
      </programlisting>
     </example>     
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para> 
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-flip">
   <refnamediv>
    <refname>array_flip</refname>
    <refpurpose>Intercambia los valores de una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>array_flip</methodname>
     <methodparam><type>array</type><parameter>trans</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_flip</function> devuelve una matriz con los valores intercambiados.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_flip</function></title>
      <programlisting role="php">
$trans = array_flip ($trans);
$original = strtr ($str, $trans);
      </programlisting>
     </example>
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para> 
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-keys">
   <refnamediv>
    <refname>array_keys</refname>
    <refpurpose>Devuelve todas las claves de una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>array_keys</methodname>
     <methodparam><type>array</type><parameter>entrada</parameter></methodparam>
     <methodparam choice="opt"><type>mixed</type><parameter>
       val_a_buscar
      </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_keys</function> devuelve las claves, num&eacute;ricas
     y de cadena, de la matriz <parameter>entrada</parameter>.
    </para>
    <para>
     Si se especifica el par&aacute;metro opcional <parameter>val_a_buscar</parameter>,
     s&oacute;lo se devuelven las claves para dicho valor. De otro modo, se
     devuelven todas las claves de la <parameter>entrada</parameter>.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_keys</function></title>
      <programlisting role="php">
$matriz = array(0 => 100, "color" => "rojo");
array_keys ($matriz);       // devuelve array (0, "color")

$matriz = array(1, 100, 2, 100);
array_keys ($matriz, 100);  // devuelve array (0, 2) 
      </programlisting>
     </example>
    </para>
    <para>
     Vea tambi&eacute;n: <function>array_values</function>.
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para> 
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-merge">
   <refnamediv>
    <refname>array_merge</refname>
    <refpurpose>Combina dos o m&aacute;s matrices</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>array_merge</methodname>
     <methodparam><type>array</type><parameter>matriz1</parameter></methodparam>
     <methodparam><type>array</type><parameter>matriz2</parameter></methodparam>
     <methodparam choice="opt"><type></type><parameter> ...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_merge</function> combina los elementos de dos o
     m&aacute;s matrices conjuntamente de modo que los valores de una son
     agregados al final de los valores de la anterior. Devuelve la 
     matriz resultante.
    </para>
    <para>
     Si las matrices de entrada tienen las mismas claves de cadena,
     el &uacute;ltimo valor para cada clave reemplazar&aacute; el valor previo de 
     la misma. Si, por el contrario, las matrices tienen la misma clave
     num&eacute;rica, esto no pasa y los valores son simplemente agregados.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_merge</function></title>
      <programlisting role="php">
$matriz1 = array ("color" => "rojo", 2, 4);
$matriz2 = array ("a", "b", "color" => "verde", "forma" => "trapezoide");
array_merge ($matriz1, $matriz2);
      </programlisting>
      <para>
       La matriz resultante ser&iacute;a array("color" => "verde", 2, 4, "a",
       "b", "forma" => "trapezoide").
      </para>
     </example>
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para>
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-pad">
   <refnamediv>
    <refname>array_pad</refname>
    <refpurpose>
     Rellena una matriz con un valor hasta el tama&ntilde;o especificado
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>array_pad</methodname>
     <methodparam><type>array</type><parameter>entrada</parameter></methodparam>
     <methodparam><type>int</type><parameter>tama_relleno</parameter></methodparam>
     <methodparam><type>mixed</type><parameter>valor_relleno</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_pad</function> Devuelve una copia de la 
     <parameter>entrada</parameter> rellenada hasta el tama&ntilde;o
     <parameter>tama_relleno</parameter> con el valor
     <parameter>valor_relleno</parameter>. Si
     <parameter>tama_relleno</parameter> es positivo, entonces la matriz es
     rellenada por la derecha, y si es negativo, por la izquierda.
     Si el valor absoluto de <parameter>tama_relleno</parameter> es menor o igual
     que el tama&ntilde;o de la <parameter>entrada</parameter> no se produce
     relleno alguno.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_pad</function></title>
      <programlisting role="php">
$entrada = array (12, 10, 9);

$resultado = array_pad ($entrada, 5, 0);
// el resultado es array (12, 10, 9, 0, 0)

$resultado = array_pad ($entrada, -7, -1);
// el resultado es array (-1, -1, -1, -1, 12, 10, 9)

$resultado = array_pad ($entrada, 2, "no");
// no rellenado
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-pop">
   <refnamediv>
    <refname>array_pop</refname>
    <refpurpose>Extrae el &uacute;ltimo elemento de la matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>mixed</type><methodname>array_pop</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_pop</function> extrae y devuelve el &uacute;ltimo valor
     de la <parameter>matriz</parameter>, acortando la 
     <parameter>matriz</parameter> en un elemento.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_pop</function></title>
      <programlisting role="php">
$pila = array ("naranja", "manzana", "frambuesa");
$fruta = array_pop ($pila);
      </programlisting>
      <para>
       Tras esto, $pila contiene s&oacute;lo 2 elementos: "naranja" y "manzana",
       y $fruta contiene "frambuesa".
      </para>
     </example>
    </para>
    <para>
     Vea tambi&eacute;n: <function>array_push</function>,
     <function>array_shift</function>, y
     <function>array_unshift</function>.
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para> 
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-push">
   <refnamediv>
    <refname>array_push</refname>
    <refpurpose>
     Inserta uno o m&aacute;s elementos al final de la matriz
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>int</type><methodname>array_push</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
     <methodparam choice="opt"><type></type><parameter>...</parameter></methodparam>
     </methodsynopsis>

    <para>
     <function>array_push</function> considera a la 
     <parameter>matriz</parameter> como una pila, e inserta las
     variables que se le pasan al final de la <parameter>matriz</parameter>. 
     La longitud de la <parameter>matriz</parameter> se incrementa en el n&uacute;mero
     de variables insertadas. Tiene el mismo efecto que ejecutar:
     <programlisting role="php">
$matriz[] = $var;
     </programlisting>
     para cada <parameter>var</parameter>.
    </para>
    <para>
     Devuelve el nuevo n&uacute;mero de elementos de la matriz.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_push</function></title>
      <programlisting role="php">
$pila = array (1, 2);
array_push($pila, "+", 3);
      </programlisting>
     </example>
     Este ejemplo dejar&aacute; $pila conteniendo 4 elementos: 1, 2, "+",
     y 3.
    </para>
    <para>
     Vea tambi&eacute;n: <function>array_pop</function>,
     <function>array_shift</function>, y
     <function>array_unshift</function>.
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para> 
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-reverse">
   <refnamediv>
    <refname>array_reverse</refname>
    <refpurpose>
     Devuelve una matriz con los elementos en orden inverso
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>array_reverse</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_reverse</function> toma la 
     <parameter>matriz</parameter> de entrada y devuelve una nueva
     matriz con los elementos en orden inverso.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_reverse</function></title>
      <programlisting role="php">
$entrada = array ("php", 4.0, array ("verde", "rojo"));
$resultado = array_reverse ($entrada);
      </programlisting>
     </example>
     Esto hace que $resultado contenga array (array ("verde", "rojo"), 4.0, "php").
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en PHP 4.0 Beta 3.
      </para>
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-shift">
   <refnamediv>
    <refname>array_shift</refname>
    <refpurpose>
     Extrae un elemento del comienzo de la matriz
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>mixed</type><methodname>array_shift</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_shift</function> extrae el primer valor de la
     <parameter>matriz</parameter> y lo devuele, acortando la 
     <parameter>matriz</parameter> en un elemnto y moviendo todo
     hacia arriba.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_shift</function></title>
      <programlisting role="php">
$args = array ("-v", "-f");
$opcion = array_shift ($args);
      </programlisting>
     </example>
     Esto da como resultado que $args tenga como elemento restante "-f" y
     que $opcion valga "-v".
    </para>
    <para>
     Vea tambi&eacute;n: <function>array_unshift</function>,
     <function>array_push</function>, y
     <function>array_pop</function>.
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para> 
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-slice">
   <refnamediv>
    <refname>array_slice</refname>
    <refpurpose>Extrae una porci&oacute;n de la matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>array_slice</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     <methodparam><type>int</type><parameter>desplazamiento</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>
       tamano
      </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_slice</function> devuelve una secuencia de 
     elementos de la <parameter>matriz</parameter> especificada por 
     los par&aacute;metros <parameter>desplazamiento</parameter> y 
     <parameter>tamano</parameter>.
    </para>
    <para>
     Si el <parameter>desplazamiento</parameter> es positivo, la secuencia
     comenzar&aacute; en dicha posici&oacute;n de la <parameter>matriz</parameter>. Si el
     <parameter>desplazamiento</parameter> es negativo, la secuencia comenzar&aacute;
     en esa posici&oacute;n desde el final de la <parameter>matriz</parameter>.
    </para>
    <para>
     Si se especifica el <parameter>tamano</parameter> y &eacute;ste es positivo,
     la secuencia contendr&aacute; tantos elementos como se diga en &eacute;l. Si fuese
     negativo, la secuencia se detendr&aacute; a tantos elementos del final de la
     matriz. Si se omite, la secuencia contendr&aacute; todos los elementos desde
     el <parameter>desplazamiento</parameter> hasta el final de la <parameter>matriz</parameter>.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_slice</function> examples</title>
      <programlisting role="php">
$entrada = array ("a", "b", "c", "d", "e");

$salida = array_slice ($entrada, 2);      // devuelve "c", "d", y "e"
$salida = array_slice ($entrada, 2, -1);  // devuelve "c", "d"
$salida = array_slice ($entrada, -2, 1);  // devuelve "d"
$salida = array_slice ($entrada, 0, 3);   // devuelve "a", "b", y "c"
      </programlisting>
     </example>
    </para>
    <para>
     Vea tambi&eacute;n: <function>array_splice</function>.
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para> 
     </note>
    </para>     
   </refsect1>
  </refentry>

  <refentry id="function.array-splice">
   <refnamediv>
    <refname>array_splice</refname>
    <refpurpose>
     Suprime una porci&oacute;n de la matriz y la sustituye por otra cosa
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>array_splice</methodname>
     <methodparam><type>array</type><parameter>entrada</parameter></methodparam>
     <methodparam><type>int</type><parameter>desplazamiento</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>tamano</parameter></methodparam>
     <methodparam choice="opt"><type>array</type><parameter>
       sustitucion
      </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_splice</function> suprime los elementos designados por 
     el <parameter>desplazamiento</parameter> y el
     <parameter>tamano</parameter> de la matriz
     <parameter>entrada</parameter>, y los sustituye con los elementos
     de la matriz de <parameter>sustitucion</parameter> si se especifica.
    </para>
    <para>
     Si el <parameter>desplazamiento</parameter> es positivo, el comienzo de la 
     parte suprimida ser&iacute;a en esa posici&oacute;n desde el comienzo de la matriz de
     <parameter>entrada</parameter>. Si el
     <parameter>desplazamiento</parameter> es negativo, se cuenta la posici&oacute;n
     desde el final de la matriz de <parameter>entrada</parameter>.
    </para>
    <para>
     Si se omite <parameter>tamano</parameter>, se suprime todo desde el
     <parameter>desplazamiento</parameter> hasta el final de la matriz. Si
     se especifica el <parameter>tamano</parameter> y es positivo, se suprimir&aacute;n
     tantos elementos como se especifica. Si fuera negativo, el final de la 
     porci&oacute;n eliminada estar&aacute; a tantos elementos del final de la matriz.
     Truco: para eliminar todo desde el <parameter>desplazamiento</parameter> 
     hasta el final de la matriz cuando tambi&eacute;n se especifica
     <parameter>sustitucion</parameter>, utilice <literal>count($entrada)</literal> 
     como <parameter>tamano</parameter>.
    </para>
    <para>
     Si se especifia la matriz de <parameter>sustitucion</parameter>, entonces
     los elementos suprimidos son reemplazados con los elementos de dicha
     matriz. Si los valores de <parameter>desplazamiento</parameter> y
     <parameter>tamano</parameter> son tales que nada es borrado, 
     los elementos de la matriz <parameter>sustitucion</parameter>
     se insertar&aacute;n en la posici&oacute;n indicada por el <parameter>desplazamiento</parameter>.
     Truco: si s&oacute;lo se va a sustituir algo por un elemento nada m&aacute;s, no hace falta
     poner <literal>array()</literal> alrededor del mismo, salvo que dicho elemento
     sea una matriz en s&iacute; mismo.
    </para>
    <para>
     Las siguientes funciones son equivalentes:
     <programlisting role="php">
array_push($entrada, $x, $y)     array_splice($entrada, count($entrada), 0, array($x, $y))
array_pop($entrada)              array_splice($entrada, -1)
array_shift($entrada)            array_splice($entrada, 0, 1)
array_unshift($entrada, $x, $y)  array_splice($entrada, 0, 0, array($x, $y))
$a[$x] = $y                    array_splice($entrada, $x, 1, $y)
     </programlisting>
    </para>
    <para>
     Devuelve una matriz que tiene los elementos eliminados
    </para>
    <para>
     <example>
      <title>Ejemplos de <function>array_splice</function></title>
      <programlisting role="php">
$entrada = array("rojo", "verde", "azul", "amarillo");

array_splice($entrada, 2);      // $entrada vale ahora array("rojo", "verde")
array_splice($entrada, 1, -1);  // $entrada vale ahora array("rojo", "amarillo")
array_splice($entrada, 1, count($entrada), "naranja");  
                              // $entrada vale ahora array("rojo", "naranja")
array_splice($entrada, -1, 1, array("negro", "marr&oacute;n")); 
                              // $entrada vale ahora array("rojo", "verde", 
                              //          "azul", "negro", "marr&oacute;n")
      </programlisting>
     </example>
    </para>
    <para>
     Vea tambi&eacute;n: <function>array_slice</function>.
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para> 
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-unshift">
   <refnamediv>
    <refname>array_unshift</refname>
    <refpurpose>Introduce uno o m&aacute;s elementos al principio
     de la matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
      <type>int</type><methodname>array_unshift</methodname>
      <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
      <methodparam choice="opt"><type></type><parameter>
	...
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_unshift</function> a&ntilde;ade los elementos que se le
     pasan al principio de la <parameter>matriz</parameter>. N&oacute;tese que la
     lista de elementos es a&ntilde;adida como un todo, de modo que los
     elementos a&ntilde;adidos mantienen su orden.
    </para>
    <para>
     Devuelve el n&uacute;mero de elementos en la <parameter>matriz</parameter>.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_unshift</function></title>
      <programlisting role="php">
$cola = array("p1", "p3");
array_unshift($cola, "p4", "p5", "p6");
      </programlisting>
     </example>
     Esto har&aacute; que $cola contenga 5 elementos: "p4", "p5", "p6",
     "p1", y "p3".
    </para>
    <para>
     Vea tambi&eacute;n: <function>array_shift</function>,
     <function>array_push</function>, y
     <function>array_pop</function>.
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para> 
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-values">
   <refnamediv>
    <refname>array_values</refname>
    <refpurpose>Devuelve todos los valores de una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>array_values</methodname>
     <methodparam><type>array</type><parameter>entrada</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_values</function> devuelve todos los valores de la 
     matriz <parameter>entrada</parameter>.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>array_values</function></title>
      <programlisting role="php">
$matriz = array("talla" => "XL", "color" => "dorado");
array_values($matriz);    // devuelve array("XL", "dorado")
      </programlisting>
     </example>
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para>
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-walk">
   <refnamediv>
    <refname>array_walk</refname>
    <refpurpose>
     Aplica una funci&oacute;n del usuario a cada elemento de una matriz.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>int</type><methodname>array_walk</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     <methodparam><type>string</type><parameter>func</parameter></methodparam>
     <methodparam><type>mixed</type><parameter>datosvarios</parameter></methodparam>
     </methodsynopsis>
    <simpara>
     Aplica la funci&oacute;n llamada <parameter>func</parameter> a cada elemento de 
     la <parameter>matriz</parameter>. La funci&oacute;n 
     <parameter>func</parameter> recibir&aacute; el valor de la matriz como primer
     par&aacute;metro y la clave como segundo. Si se proporciona el
     par&aacute;metro <parameter>datosvarios</parameter> ser&aacute; pasado como
     tercer par&aacute;metro a la funci&oacute;n de usuario.
    </simpara>
    <simpara>
     Si <parameter>func</parameter> necesita m&aacute;s de dos o 3 argumentos,
     dependiendo de <parameter>datosvarios</parameter>, se generar&aacute; un
     aviso cada vez que <function>array_walk</function> llama a
     <parameter>func</parameter>. Estos avisos pueden suprimirse si
     se pone '@' antes de la llamada a <function>array_walk</function>,
     o usando la funci&oacute;n <function>error_reporting</function>.
    </simpara>
    <note>
     <para>
      Si <parameter>func</parameter> precisa trabajar con los valores
      reales de la matriz, especifique que el valor del primer par&aacute;metro
      de <parameter>func</parameter> debe pasarse por referencia. Desde ese
      instante, los cambios realizados sobre dichos elementos tambi&eacute;n ser&aacute;n
      realizados en la propia matriz.
     </para>
    </note>
    <note>
     <para>
      El pasar la clave y los datos de usuario a <parameter>func</parameter> 
      fue una caracter&iacute;stica a&ntilde;adida en PHP 4.0.
     </para>
     <para>
      En PHP 4 se debe llamar <function>reset</function> las veces necesarias,
      pues <function>array_walk</function> no reajusta la matriz por
      defecto.
     </para>
    </note>
    <para>
     <example>
      <title>Ejemplo de <function>array_walk</function></title>
      <programlisting role="php">
$frutas = array ("d"=>"lim&oacute;n", "a"=>"naranja", "b"=>"pl&aacute;tano", "c"=>"manzana");

function test_alterar (&$item1, $clave, $prefix) {
   $item1 = "$prefix: $item1";
}

function test_ver ($item2, $clave) {
   echo "$clave. $item2&lt;br&gt;\n";
}

array_walk ($frutas, 'test_ver');
reset ($frutas);
array_walk ($frutas, 'test_alterar', 'fruta');
reset ($frutas);
array_walk ($frutas, 'test_ver');
      </programlisting>
     </example>
    </para>
    <simpara>
     Vea tambi&eacute;n: <function>each</function> y <function>list</function>.
    </simpara>
   </refsect1>
  </refentry>
    
  <refentry id="function.arsort">
   <refnamediv>
    <refname>arsort</refname>
    <refpurpose>
     Ordena una matriz en orden inverso y mantiene la asociaci&oacute;n de &iacute;ndices
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>void</type><methodname>arsort</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Esta funci&oacute;n ordena una matriz de modo que los &iacute;ndices mantengan
     su correlaci&oacute;n con los elementos de la misma a los que est&aacute;n asociados.
     Esto se utiliza principalmente para ordenar matrices asociativas
     en las que el orden de los elementos es importante.
     <example>
      <title>Ejemplo de <function>arsort</function></title>
      <programlisting role="php">
$frutas = array ("d"=>"lim&oacute;n", "a"=>"naranja", "b"=>"pl&aacute;tano", "c"=>"manzana");
arsort ($frutas);
for (reset ($frutas); $clave = key ($frutas); next ($frutas)) {
    echo "frutas[$clave] = ".$frutas[$clave]."\n";
}
      </programlisting>
     </example>
     Este ejemplo mostrar&iacute;a:
     <computeroutput>
frutas[b] = pl&aacute;tano
frutas[a] = naranja
frutas[c] = manzana
frutas[d] = lim&oacute;n
     </computeroutput>
     Las frutas han sido ordenadas en orden alfab&eacute;tico inverso y los
     &iacute;ndices asociados con cada elemento se han mantenido.
    </para>
    <para>
     Vea tambi&eacute;n: <function>asort</function>, <function>rsort</function>,
     <function>ksort</function>, y <function>sort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.asort">
   <refnamediv>
    <refname>asort</refname>
    <refpurpose>Ordena una matriz y mantiene la asociaci&oacute;n de &iacute;ndices</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>void</type><methodname>asort</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Esta funci&oacute;n ordena una matriz de modo que los &iacute;ndices mantengan
     su correlaci&oacute;n con los elementos de la misma a los que est&aacute;n asociados.
     Esto se utiliza principalmente para ordenar matrices asociativas
     en las que el orden de los elementos es importante.
     <example>
      <title>Ejemplo de <function>asort</function></title>
      <programlisting role="php">
$frutas = array ("d"=>"lim&oacute;n", "a"=>"naranja", "b"=>"pl&aacute;tano", "c"=>"manzana");
asort ($frutas);
for (reset ($frutas); $clave = key ($frutas); next ($frutas)) {
    echo "frutas[$clave] = ".$frutas[$clave]."\n";
}
      </programlisting>
     </example>
     Este ejemplo mostrar&aacute;:
     <computeroutput>
frutas[d] = lim&oacute;n
frutas[a] = naranja
frutas[c] = manzana
frutas[d] = pl&aacute;tano
     </computeroutput>
     Las frutas han sido ordenadas en orden alfab&eacute;tico y los &iacute;ndices
     asociados con cada elemento se han mantenido.
    </para>
    <para>
     Vea tambi&eacute;n: <function>arsort</function>, <function>rsort</function>,
     <function>ksort</function>, y <function>sort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.compact">
   <refnamediv>
    <refname>compact</refname>
    <refpurpose>
     Crea una matriz que contiene variables y sus valores
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>compact</methodname>
     <methodparam><parameter>string nombrevar | array
     nombrevars</parameter></methodparam>
     <methodparam choice="opt"><type></type><parameter>...</parameter></methodparam>
     </methodsynopsis>

    <para>
     <function>compact</function> toma un n&uacute;mero variable de par&aacute;metros.
     Cada uno puede ser tanto una cadena que contiene el nombre
     de la variable, como una matriz de nombres de variable. La 
     matriz puede contener otras matrices de nombres de variable
     en su interior; <function>compact</function> los procesa
     recursivamente.
    </para>
    <para>
     Para cada uno de estos, <function>compact</function> busca una 
     variable con dicho nombre en la tabla de s&iacute;mbolos y la a&ntilde;ade a
     la matriz de salida de modo que el nombre de la variable es la
     clave y el contenido de &eacute;sta es el valor para dicha clave. Para
     resumir, hace lo contrario de <function>extract</function>.
     Devuelve la matriz de salida con las variables a&ntilde;adidas a la misma.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>compact</function></title>
      <programlisting role="php">
$ciudad = "San Francisco";
$estado = "CA";
$evento = "SIGGRAPH";

$location_vars = array ("ciudad", "estado");

$resultado = compact ("evento", $location_vars);
      </programlisting>
      <para>
       Tras esto, $resultado valdr&aacute; array ("evento" => "SIGGRAPH",
       "ciudad" => "San Francisco", "estado" => "CA").
      </para>
     </example>
    </para>
    <para>
     Vea tambi&eacute;n: <function>extract</function>.
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para>
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.count">
   <refnamediv>
    <refname>count</refname>
    <refpurpose>Cuenta los elementos de una variable</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>int</type><methodname>count</methodname>
     <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
     </methodsynopsis>
    <para>
     Devuelve el n&uacute;mero de elementos en <parameter>var</parameter>,
     que t&iacute;picamente es una matriz (porque cualquier otra cosa tendr&iacute;a
     s&oacute;lo un elemento).
    </para>
    <para>
     Devuele 1 si la variable no es una matriz.
    </para>
    <para>
     Devuelve 0 si la variable no tiene valor.
     <warning>
      <para>
       <function>count</function> puede devolver 0 para una variable
       sin valor, pero tambi&eacute;n puede devolver 0 para una variable
       ya inicializada pero con una matriz vac&iacute;a. Utilice
       <function>isset</function> para comprobar si una variable est&aacute;
       inicializada.
      </para>
     </warning>
    </para>
    <para>
     Vea tambi&eacute;n: <function>sizeof</function>,
     <function>isset</function>, y
     <function>is_array</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.current">
   <refnamediv>
    <refname>current</refname>
    <refpurpose>Devuelve el elemento actual de una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>mixed</type><methodname>current</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Cada matriz tiene un puntero interno al elemento "actual", que se
     inicializa al primer elemento insertado en la misma.
    </para>
    <para>
     La funci&oacute;n <function>current</function> simplemente devuelve el
     elemento de la tabla al que apunta el puntero interno. No mueve
     el puntero de ninguna manera. Si el puntero interno apunta fuera
     del final de la lista de elementos, <function>current</function>
     devuelve &false;.
     <warning>
      <para>
       Si la matriz contiene elementos vac&iacute;os (0 &oacute; "", la cadena
       vac&iacute;a) esta funci&oacute;n devolver&aacute; &false; tambi&eacute;n para dichos
       elementos. Esto hace imposible determinar si se est&aacute; realmente
       al final de la lista en tales matrices usando <function>current</function>.
       Para recorrer adecuadamente una matriz que pueda contener elementos
       vac&iacute;os, utilice la funci&oacute;n <function>each</function>.
      </para>
     </warning>
    </para>
    <para>
     Vea tambi&eacute;n: <function>end</function>, <function>next</function>,
     <function>prev</function> y <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.each">
   <refnamediv>
    <refname>each</refname> 
    <refpurpose>
     Devuelve el siguiente par clave/valor de una matriz
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>each</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Devuelve el par clave/valor actual para la 
     <parameter>matriz</parameter> y avanza el cursor de la
     misma. Esta pareja se devuele en una matriz de 4 elementos,
     con las claves 
     <emphasis>0</emphasis>, <emphasis>1</emphasis>,
     <emphasis>key</emphasis>, y
     <emphasis>value</emphasis>. Los elementos <emphasis>0</emphasis> y
     <emphasis>key</emphasis> contienen el nombre de clave
     del elemento de la matriz, y <emphasis>1</emphasis> y
     <emphasis>value</emphasis> contienen los datos.
    </para>
    <para>
     Si el puntero interno para la matriz apunta pasado el final del
     contenido de la matriz, <function>each</function> devuelve &false;.
    </para>
    <para>
     <example>
      <title>Ejemplos de <function>each</function></title>
      <programlisting role="php">
$chorrada = array ("bob", "fred", "jussi", "jouni", "egon", "marliese");
$tonteria = each ($chorrada);
      </programlisting>
      <para>
       <literal>$tonteria</literal> contiene ahora los siguientes pares
       clave/valor:
       <itemizedlist spacing="compact">
        <listitem><simpara>0 => 0</simpara></listitem>
        <listitem><simpara>1 => 'bob'</simpara></listitem>
        <listitem><simpara>key => 0</simpara></listitem>
        <listitem><simpara>value => 'bob'</simpara></listitem>
       </itemizedlist>

       <programlisting role="php">
$chorrada = array ("Robert" => "Bob", "Seppo" => "Sepi");
$tonteria = each ($chorrada);
       </programlisting>
      </para>
      <para>
       <literal>$tonteria</literal> contiene ahora los siguientes pares
       clave/valor:
       <itemizedlist spacing="compact">
        <listitem><simpara>0 => 'Robert'</simpara></listitem>
        <listitem><simpara>1 => 'Bob'</simpara></listitem>
        <listitem><simpara>key => 'Robert'</simpara></listitem>
        <listitem><simpara>value => 'Bob'</simpara></listitem>
       </itemizedlist>
      </para>
     </example>
    </para>
      
    <para>
     <function>each</function> se usa normalmente de forma conjunta a
     <function>list</function> para recorrer una matriz; por ejemplo,
     $HTTP_POST_VARS: 
     <example>
      <title>
       Recorriendo $HTTP_POST_VARS con <function>each</function>
      </title>
      <programlisting role="php">
echo "Valores enviados con el m&eacute;todo POST:&lt;br&gt;";
reset ($HTTP_POST_VARS);
while (list ($clave, $val) = each ($HTTP_POST_VARS)) {
    echo "$clave => $val&lt;br&gt;";
}
      </programlisting>
     </example>
    </para>

    <para>
     Cuando se ha ejecutado <function>each</function>, el cursor de la
     matriz quedar&aacute; en el siguiente elemento de la misma, o en el 
     &uacute;ltimo si llega al final de &eacute;sta.
    </para>
    <para>
     Vea tambi&eacute;n: <function>key</function>, <function>list</function>,
     <function>current</function>, <function>reset</function>,
     <function>next</function>, y <function>prev</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.end">
   <refnamediv>
    <refname>end</refname>
    <refpurpose>
     Mueve el puntero interno de una tabla al &uacute;ltimo elemento
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <methodname>end</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>end</function> avanza el puntero interno de la 
     <parameter>matriz</parameter> al &uacute;ltimo elemento.
    </para>
    <para>
     Vea tambi&eacute;n: <function>current</function>,
     <function>each</function>, <function>end</function>,
     <function>next</function>, y <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.extract">
   <refnamediv>
    <refname>extract</refname>
    <refpurpose>
     Importa variables a la tabla de s&iacute;mbolos desde una matriz
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>void</type><methodname>extract</methodname>
     <methodparam><type>array</type><parameter>matriz_vars</parameter></methodparam>
     <methodparam choice="opt"><type>int</type><parameter>tipo_extraccion</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>prefijo</parameter></methodparam>
     </methodsynopsis>
    <para>
     Esta funci&oacute;n se utiliza para importar variables desde una matriz
     a la tabla de s&iacute;mbolos actual. Toma la matriz asoiativa
     <parameter>matriz_vars</parameter> y trata las claves como nombres
     de variable y los valores como los valores de &eacute;stas. Para cada
     par clave/valor crear&aacute; una variable en la tabla de s&iacute;mbolos actual,
     sujeto a los par&aacute;metros <parameter>tipo_extraccion</parameter> y
     <parameter>prefijo</parameter>.
    </para>
    <para>
     <function>extract</function> controla las colisiones con las
     variables que ya existen. La forma de tratar &eacute;stas se determina
     por el <parameter>tipo_extraccion</parameter>. Puede tener &uacute;nicamente
     uno de los siguientes valores:
     <variablelist>
      <varlistentry>
       <term>EXTR_OVERWRITE</term>
       <listitem>
	<simpara>
	 Si hay colisi&oacute;n, sobreescribe la variable existente.
	</simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_SKIP</term>
       <listitem>
	<simpara>
	 Si hay colisi&oacute;n, no sobreescribas la variable existente.
	</simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_PREFIX_SAME</term>
       <listitem>
	<simpara>Si hay una colisi&oacute;n, a&ntilde;ade el <parameter>prefijo</parameter>
	a la nueva variable.
	</simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_PREFIX_ALL</term>
       <listitem>
	<simpara>
	 A&ntilde;ade el <parameter>prefijo</parameter> a todas las variables.
	</simpara>
       </listitem>
      </varlistentry>
     </variablelist>
    </para>
    <para>
     Si no se especifica <parameter>tipo_extraccion</parameter>, se asume que
     vale EXTR_OVERWRITE.
    </para>
    <para>
     N&oacute;tese que el <parameter>prefijo</parameter> s&oacute;lo se necisita si
     <parameter>tipo_extraccion</parameter> vale EXTR_PREFIX_SAME o
     EXTR_PREFIX_ALL.
    </para>
    <para>
     <function>extract</function> comprueba si cada clave es un nombre
     v&aacute;lido de variable, y s&oacute;lo lo importa si lo es.
    </para>
    <note>
     <para>
      N.T.: En el caso espa&ntilde;ol, no valdr&iacute;a "a&ntilde;o" como nombre variable
      (pero s&iacute; como clave en una matriz cualquiera).
     </para>
    </note>
    <para>
     Un uso posible para extract ser&iacute;a importar en la tabla de s&iacute;mbolos
     las variables contenidas en la matriz asociativa que devuelve
     <function>wddx_deserialize</function>.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>extract</function></title>
      <programlisting role="php">
&lt;php?

/* Suponemos que $matriz_var es una matriz devuelta por 
   wddx_deserialize */

$tamano = "grande";
$matriz_var = array ("color" => "azul",
                    "tamano"  => "media",
                    "forma" => "esfera");
extract ($matriz_var, EXTR_PREFIX_SAME, "wddx");

print "$color, $tamano, $forma, $wddx_tamano\n";

?>
      </programlisting>
     </example>
    </para>
    <para>
     El programa anterior producir&aacute;:
     <programlisting>
azul, grande, esfera, media
     </programlisting>
    </para>
    <para>
     La variable $tamano no fue sobreescrita porque especificamos
     EXTR_PREFIX_SAME, que provoc&oacute; la creaci&oacute;n de $wddx_tamano.
     Si se hubiera especificado EXTR_SKIP, $wddx_tamano ni siquiera
     habr&iacute;a sido creada. EXTR_OVERWRITE habr&iacute;a provocado que $tamano 
     tuviera el valor "media", y EXTR_PREFIX_ALL habr&iacute;a provocado que
     aparecieran nuevas variables llamadas $wddx_color, $wddx_tamano,
     y $wddx_forma.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.in-array">
   <refnamediv>
    <refname>in_array</refname>
    <refpurpose>Devuelve &true; si un valor est&aacute; en una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>bool</type><methodname>in_array</methodname>
     <methodparam><type>mixed</type><parameter>aguja</parameter></methodparam>
     <methodparam><type>array</type><parameter>pajar</parameter></methodparam>
     </methodsynopsis>
    <para>
     Busca la <parameter>aguja</parameter> en el <parameter>pajar</parameter>,
     y devuelve &true; si se encuentra y &false; en caso contrario.
    </para>
    <para>
     <example>
      <title>Ejemplo de <function>in_array</function></title>
      <programlisting role="php">
$os = array ("Mac", "NT", "Irix", "Linux");
if (in_array ("Irix", $os))
    print "Encontrado Irix";
      </programlisting>
     </example>
     <note>
      <para>
       Esta funci&oacute;n fue a&ntilde;adida en el PHP 4.0.
      </para> 
     </note>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.key">
   <refnamediv>
    <refname>key</refname>
    <refpurpose>Obtiene una clave de una matriz asociativa</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>mixed</type><methodname>key</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>key</function> devuelve el elemento &iacute;ndice de la posici&oacute;n
     actual en la matriz.
    </para>
    <para>
     Vea tambi&eacute;n: <function>current</function>, <function>next</function>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.krsort">
   <refnamediv>
    <refname>krsort</refname>
    <refpurpose>Ordena una matriz por clave en orden inverso</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>int</type><methodname>krsort</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Ordena una matriz por clave en orden inverso, manteniendo las correlaciones
     clave a dato. Esto es &uacute;til principalmente en matrices asociativas.
     <example>
      <title>Ejemplo de <function>krsort</function></title>
      <programlisting role="php">
$frutas = array ("d"=>"lim&oacute;n", "a"=>"naranja", "b"=>"pl&aacute;tano", "c"=>"manzana");
krsort ($frutas);
for (reset ($frutas); $clave = key ($frutas); next ($frutas)) {
    echo "frutas[$clave] = ".$frutas[$clave]."\n";
}
      </programlisting>
     </example>
     Este ejemplo mostrar&aacute;:
     <computeroutput>
frutas[d] = lim&oacute;n
frutas[c] = manzana
frutas[b] = pl&aacute;tano
frutas[a] = naranja
     </computeroutput>
    </para>
    <simpara>
     Vea tambi&eacute;n: <function>asort</function>, <function>arsort</function>,
     <function>ksort</function> <function>sort</function>, y
     <function>rsort</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.ksort">
   <refnamediv>
    <refname>ksort</refname>
    <refpurpose>Ordena una matriz por clave</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>int</type><methodname>ksort</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Ordena una matriz por clave, manteniendo las correlaciones clave a
     dato. Esto es &uacute;til principalmente en matrices asociativas.
     <example>
      <title>Ejemplo de <function>ksort</function></title>
      <programlisting role="php">
$frutas = array ("d"=>"lim&oacute;n", "a"=>"naranja", "b"=>"pl&aacute;tano", "c"=>"manzana");
ksort ($frutas);
for (reset ($frutas); $clave = key ($frutas); next ($frutas)) {
    echo "frutas[$clave] = ".$frutas[$clave]."\n";
}
      </programlisting>
     </example>
     Este ejemplo mostrar&aacute;:
     <computeroutput>
frutas[a] = naranja
frutas[b] = pl&aacute;tano
frutas[c] = manzana
frutas[d] = lim&oacute;n
     </computeroutput>
    </para>
    <simpara>
     Vea tambi&eacute;n: <function>asort</function>, <function>arsort</function>, 
     <function>sort</function>, y <function>rsort</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.list">
   <refnamediv>
    <refname>list</refname>
    <refpurpose>
     Asigna variables como si fueran una matriz
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>void</type><methodname>list</methodname>
     <methodparam rep="repeat"><type>mixed</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     Como <function>array</function>, esta no es realmente una funci&oacute;n,
     sino una construcci&oacute;n del lenguaje. <function>list</function> se 
     usa para asignar una lista de variables en una sola operaci&oacute;n.
     <example>
      <title>Ejemplo de <function>list</function></title>
      <programlisting role="php">
&lt;table>
 &lt;tr>
  &lt;th>Nombre empleado&lt;/th>
  &lt;th>Sueldo&lt;/th>
 &lt;/tr>

&lt;?php

$resultado = mysql($conn, "SELECT id, nombre, salario FROM empleados");
while (list($id, $nombre, $salario) = mysql_fetch_row($resultado)) {
    print(" &lt;tr>\n".
          "  &lt;td>&lt;a href=\"info.php3?id=$id\">$nombre&lt;/a>&lt;/td>\n".
          "  &lt;td>$salario&lt;/td>\n".
          " &lt;/tr>\n");
}

?>

&lt;/table>
      </programlisting>
     </example>
    </para>
    <para>
     Vea tambi&eacute;n: <function>each</function>, <function>array</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.next">
   <refnamediv>
    <refname>next</refname>
    <refpurpose>
     Avanza el puntero interno de una matriz
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>mixed</type><methodname>next</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Devuelve el elemento de la matriz que ocupa el lugar siguiente
     al apuntado por el puntero interno, o &false; si no hay m&aacute;s elementos.
    </para>
    <para>
     <function>next</function> se comporta como
     <function>current</function>, con una diferencia. Avanza el puntero
     interno de la matriz en una posici&oacute;n antes de devolver el elemento.
     Eso significa que devuelve el siguiente elemento de la matriz y 
     que avanza el puntero interno en uno. Si al avanzar se pasa del
     final de la lista de elementos, <function>next</function> devuelve &false;.
     <warning>
      <para>
       Si la matriz contiene elementos vac&iacute;os, esta funci&oacute;n tambi&eacute;n
       devolver&aacute; &false; para dichos elementos. Para recorrer adecuadamente
       una matriz que pueda contener elementos vac&iacute;os, vea la funci&oacute;n
       <function>each</function>.
      </para>
     </warning>
    </para>
    <para>
     Vea tambi&eacute;n:
     <function>current</function>, <function>end</function>
     <function>prev</function> y <function>reset</function>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.pos">
   <refnamediv>
    <refname>pos</refname>
    <refpurpose>Obtiene el elemento actual de una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>mixed</type><methodname>pos</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <simpara>
     Este es un alias para <function>current</function>.
    </simpara>
    <para>
     Vea tambi&eacute;n:
     <function>end</function>, <function>next</function>,
     <function>prev</function> y <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.prev">
   <refnamediv>
    <refname>prev</refname>
    <refpurpose>Rebobina el puntero interno de una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>mixed</type><methodname>prev</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Devuelve el elemento de la matriz que est&aacute; en la posici&oacute;n anterior a 
     la que apuntaba previamente el puntero interno, o &false; si no hay m&aacute;s 
     elementos.
     <warning>
      <para>
       Si la matriz contiene elementos vac&iacute;os, esta funci&oacute;n tambi&eacute;n
       devolver&aacute; &false; para dichos elementos. Para recorrer adecuadamente
       una matriz que puede contener elementos vac&iacute;os, vea la funci&oacute;n
       <function>each</function>.
      </para>
     </warning>
    </para>
    <para>  
     <function>prev</function> se comporta igual que 
     <function>next</function>, excepto que rebobina el puntero
     interno una posici&oacute;n en lugar de avanzarlo.
    </para>
    <para>
     Vea tambi&eacute;n: <function>current</function>, <function>end</function>
     <function>next</function> y <function>reset</function>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.range">
   <refnamediv>
    <refname>rango</refname>
    <refpurpose>
     Crea una matriz que contiene un rango de enteros
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>array</type><methodname>rango</methodname>
     <methodparam><type>int</type><parameter>bajo</parameter></methodparam>
     <methodparam><type>int</type><parameter>alto</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>rango</function> devuelve una matriz de enteros
     desde <parameter>bajo</parameter> hasta <parameter>alto</parameter>,
     ambos inclusive.
    </para>
    <para>
     Vea un ejemplo de su uso en la funci&oacute;n <function>shuffle</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.reset">
   <refnamediv>
    <refname>reset</refname>
    <refpurpose>
     Fija el puntero interno de una matriz a su primer elemento
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>mixed</type><methodname>reset</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>reset</function> rebobina el puntero interno de la
     <parameter>matriz</parameter> a su primer elemento.
    </para>
    <para>
     <function>reset</function> devuelve el valor del primer elemento
     de la matriz.
    </para>
    <para>
     Vea tambi&eacute;n: <function>current</function>,
     <function>each</function>, <function>next</function>,
     <function>prev</function>, y <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.rsort">
   <refnamediv>
    <refname>rsort</refname>
    <refpurpose>Ordena una matriz en orden inverso</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>void</type><methodname>rsort</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Esta funci&oacute;n ordena una matriz en orden inverso (mayor a menor).
     <example>
      <title>Ejemplo de <function>rsort</function></title>
	<programlisting role="php">
$frutas = array ("lim&oacute;n", "naranja", "pl&aacute;tano", "manzana");
rsort ($frutas);
for (reset ($frutas); list ($clave, $valor) = each ($frutas); ) {
    echo "frutas[$clave] = ", $valor, "\n";
}
      </programlisting>
     </example>
     Este ejemplo mostrar&aacute;:
     <computeroutput>
frutas[0] = pl&aacute;tano
frutas[1] = naranja
frutas[2] = manzana
frutas[3] = lim&oacute;n
     </computeroutput>
     Las frutas han sido ordenadas en orden alfab&eacute;tico inverso.
    </para>
    <para>
     Vea tambi&eacute;n: <function>arsort</function>,
     <function>asort</function>, <function>ksort</function>,
     <function>sort</function>, y <function>usort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.shuffle">
   <refnamediv>
    <refname>shuffle</refname>
    <refpurpose>Mezcla una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>void</type><methodname>shuffle</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Esta funci&oacute;n mezcla (cambia aleatoriamente el orden de los elementos
     de) una matriz.
     <example>
      <title>Ejemplo de <function>shuffle</function></title>
      <programlisting role="php">
$numeros = range (1,20);
srand (time());
shuffle ($numeros);
while (list(, $numero) = each ($numeros)) {
    echo "$numero ";
}
      </programlisting>
     </example>
    </para>
    <para>
     Vea tambi&eacute;n: <function>arsort</function>, <function>asort</function>,
     <function>ksort</function>, <function>rsort</function>,
     <function>sort</function> y <function>usort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.sizeof">
   <refnamediv>
    <refname>sizeof</refname>
    <refpurpose>Obtiene el n&uacute;mero de elementos de una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>int</type><methodname>sizeof</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Devueve el n&uacute;mero de elementos de la matriz.
    </para>
    <para>
     Vea tambi&eacute;n: <function>count</function>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.sort">
   <refnamediv>
    <refname>sort</refname>
    <refpurpose>Ordena una matriz</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>void</type><methodname>sort</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     </methodsynopsis>
    <para>
     Esta funci&oacute;n ordena una matriz. Los elementos estar&aacute;n ordenados
     de menor a mayor cuando la funci&oacute;n termine.
     <example>
      <title>Ejemplo de <function>sort</function></title>
	<programlisting role="php">
$frutas = array ("lim&oacute;n", "naranja", "pl&aacute;tano", "manzana");
sort ($frutas);
for (reset ($frutas); $clave = key ($frutas); next ($frutas)) {
    echo "frutas[$clave] = ".$frutas[$clave]."\n";
}
      </programlisting>
     </example>
     Este ejemplo mostrar&aacute;:
     <computeroutput>
frutas[0] = lim&oacute;n
frutas[1] = manzana
frutas[2] = naranja
frutas[3] = pl&aacute;tano
     </computeroutput>
     Las frutas han sido ordenadas en orden alfab&eacute;tico.
    </para>
    <para>
     Vea tambi&eacute;n: <function>arsort</function>,
     <function>asort</function>, <function>ksort</function>,
     <function>rsort</function>, y <function>usort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.uasort">
   <refnamediv>
    <refname>uasort</refname>
    <refpurpose>
     Ordena una matriz mediante una funci&oacute;n de comparaci&oacute;n 
     definida por el usuario y mantiene la asociaci&oacute;n de &iacute;ndices
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>void</type><methodname>uasort</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     <methodparam><type>function</type><parameter>func_comparar</parameter></methodparam>
     </methodsynopsis>
    <para>
     Esta funci&oacute;n ordena una matriz de modo que los &iacute;ndices de la misma
     mantengan su correlaci&oacute;n con los elementos a los que est&aacute;n asociados.
     Esto se utiliza principalmente para ordenar matrices asociativas
     en las que el orden de los elementos es importante. La funci&oacute;n
     de comparaci&oacute;n viene definida por el usuario.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.uksort">
   <refnamediv>
    <refname>uksort</refname>
    <refpurpose>
     Ordena una matriz por claves mediante una funci&oacute;n definida por el usuario
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>void</type><methodname>uksort</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     <methodparam><type>function</type><parameter>func_comparar</parameter></methodparam>
     </methodsynopsis>
    <para>
     Esta funci&oacute;n ordenar&aacute; las claves de una matriz utilizando una funci&oacute;n
     de comparaci&oacute;n suministrada por el usuario. Si la matriz a ordenar 
     necesita utilizar un criterio poco trivial, esta es la funci&oacute;n que
     deber&aacute; usar.

     <example>
      <title>Ejemplo de <function>uksort</function></title>
      <programlisting role="php">
function micomparar ($a, $b) {   
    if ($a == $b) return 0;
    return ($a > $b) ? -1 : 1;
}
$a = array (4 => "cuatro", 3 => "tres", 20 => "veinte", 10 => "diez");
uksort ($a, micomparar);
while (list ($clave, $valor) = each ($a)) {
    echo "$clave: $valor\n";
}
      </programlisting>
     </example>
     Este ejemplo mostrar&aacute;:
     <computeroutput>
20: veinte
10: diez
4: cuatro
3: tres
     </computeroutput>
    </para>
    <para>
     Vea tambi&eacute;n: <function>arsort</function>,
     <function>asort</function>, <function>uasort</function>,
     <function>ksort</function>, <function>rsort</function>, y
     <function>sort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.usort">
   <refnamediv>
    <refname>usort</refname>
    <refpurpose>
     Ordena una matriz por valores mediante una funcion definida por el usuario
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Descripci&oacute;n</title>
     <methodsynopsis>
     <type>void</type><methodname>usort</methodname>
     <methodparam><type>array</type><parameter>matriz</parameter></methodparam>
     <methodparam><type>function</type><parameter>func_comparar</parameter></methodparam>
     </methodsynopsis>
    <para>
     Esta funci&oacute;n ordenar&aacute; una matriz por sus valores utilizando una
     funci&oacute;n suministrada por el usuario. Si la matriz que desea ordenar
     necesita utilizar un criterio poco trivial, esta es la funci&oacute;n que
     deber&aacute; usar.
    </para>
    <para>
     La funci&oacute;n de comparaci&oacute;n deber&aacute; devolver un entero menor, igual,
     o mayor que cero, si el primer argumento se considera respectivamente
     menor que, igual que, o mayor que el segundo. Si dos miembros 
     resultan ser iguales, su orden en la matriz ordenada ser&aacute; cualquiera.
     <example>
      <title>Ejemplo de <function>usort</function></title>
      <programlisting>
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 ($clave, $valor) = each ($a)) {
    echo "$clave: $valor\n";
}
      </programlisting>
     </example>
     Este ejemplo mostrar&aacute;:
     <computeroutput>
0: 6
1: 5
2: 3
3: 2
4: 1
     </computeroutput>
     <note>
      <para>
       Obviamente en este caso trivial la funci&oacute;n <function>rsort</function>
       habr&iacute;a sido m&aacute;s apropiada.
      </para>
     </note>
     <warning>
      <para>
       La funci&oacute;n quicksort subyacente en ciertas librer&iacute;as de C (tales
       como las de Solaris) pueden hacer que el PHP falle si la funci&oacute;n de
       comparaci&oacute;n no devuelve valores consistentes.
      </para>
     </warning>
    </para>
    <para>
     Vea tambi&eacute;n: <function>arsort</function>,
     <function>asort</function>, <function>ksort</function>,
     <function>rsort</function> y <function>sort</function>.
    </para>
   </refsect1>
  </refentry>

 </reference>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"../../manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->