Pueden guardar más de un valor y se les nombra así: array, arreglo o vector y es una lista o colección de datos que se agrupan de forma contigua en la memoria de la computadora, y para acceder a él y sus elementos utilizando una misma variable y los índices de cada elemento.
los arrays nos permiten manejar la información de forma más fácil y cómoda, pudiendo buscar, agrupar, recorrer y ordenar listas de datos de una manera sencilla.
Las matrices en PHP nos permiten almacenar elementos de diferented tipos de datos dentro de una misma matriz.
las principales variables de PHP están almacenadas en matrices ($_SERVER, $_GET.
$_POST, $_SESSlON, $_ENVIRONMENT, etc.).
Existen muchos tipos de arrays: listas(vector), diccionarios, colas, pilas, tablas, hash, etc. Todas ellas parten de un enfoque básico que nos permiten clasificar las matrices según el tipo de índice utilizado.
Arrays enumerativos: Al definir un Array, si no se especifica una clave, PHP asigna automáticamente un valor numérico ordenado, creando así un array enumerativo a partir del "0". Son los que poseen números en las claves.
Arrays asociativos: Son los que tienen claves de tipo caracter o cadena de caracteres, también denominadas tablas, hash o indexadas por cadenas. Los Arrays pueden contener claves o índices numéricos y también de caracteres, (arrays mixtos), son una mezcla de enumerativos y de asociativos.
Existen dos formas para definir un array:
Definición explícita: es necesaria la palabra array() seguido de sus datos entre paréntesis, además, los datos almacenados son del tipo clave => valor (key => value), o simplemente valor (en este caso PHP asigna automáticamente las claves, asociando el primer valor a "0", el 2º valor a 1, y así con el resto de valores del array); los elementos deben ir separados por una coma (,), a cada uno de estos pares de datos los denominamos elementos.
// Array tipo cadena de carácteres $arrayNumerico = array('Alpha', 'Gamma', 'Omega'); // Array tipo numérico $arrayNumerico = array(9, 8, 20); // Elemento compuestos por una clave y su valor $arrayClavesValor = array('Pepe' => 35, 'Carla' => 29, 'Noelia' => 41); // Tipos numérico y de cadena $arrayClavesValorMixto = array(1 => 'uno', 2 => 'dos', 'program' => 'acción'); // Crear un Array vacio $arrayVacio = array();
Definición por operador "[]": Detrás del nombre del array va la clave dentro de corchetes [] seguido de la asignación = y terminando con el valor que deseamos para ese elemento.
Cuando los índices de un array son numéricos o enteros entonces es un Array escalar, también se la conoce como matriz enumerada o indexada, su índice numérico empieza con una base 0 así que el índice final será un número menor que su número de elementos. Al contrario, si los índices fueran cadenas pasarian a llamarse Array asociativo.
// Array escalar con operador array "[ ]" $arrayEscalarConIndice[2] = 'España'; // (el índice numérico lo añadimos nosotros) $arrayEscalarSinIndice[] = 'Portugal'; // Array escalar (índice numérico automático) $arrayAsociativo["cadena"] = 'Francia'; // Array asociativo (índice de cadena)
Asignación automática de índices en el constructor de array, cuando no se le asigna ningún índice a los valores del array, PHP los asigna automáticamente, asignando al primer elemento el '0' e ir sumando uno para cada elemento del array.
$uniArray = array("Alemania", "Austria", "Bélgica");
echo "<table>";
echo "<tr>";
echo "<th>Elemento</th>";
// Recorrer los índices
for ($ind = 0; $ind < count($uniArray); $ind++)
echo"<td>$ind</td>";
echo "</tr>";
echo "<tr>";
echo "<th>Valor</th>";
// Recorrer los valores
for ($ind = 0; $ind < count($uniArray); $ind++)
echo "<td> $uniArray[$ind] </td>";
echo "</tr>";
echo "</table>";
| Índices | 0 | 1 | 2 |
|---|---|---|---|
| Valores | Alemania | Austria | Bélgica |
Operadores aritméticos: son los que nos permiten hacer calculos simples como sumar (+), restar (-), multiplicar (*), dividir (/) y sacar el módulo (%).
El operador + devuelve el array del lado derecho añadido al array del lado izquierdo; para las claves que existan en ambos arrays, serán utilizados los elementos del array de la izquierda y serán ignorados los elementos correspondientes del array de la derecha.
Este operador elimina elementos comunes, cuando haya elemento con claves de cadena duplicadas.
Los elementos de los arrays son iguales para la comparación si éstos tienen la misma clave y valor.
$a = array("a" => "manzana", "b" => "banana");
$b = array("a" => "pera", "b" => "fresa", "c" => "cereza");
$d = array("c" => 2, "x" => "uva", "z" => "higo");Unión de $a y $b:
$c = $a + $b; // Unión de $a y $b foreach($c as $val){ if($val == "cereza"){ // Si hay igualdad echo $val; }else{ echo $val . " -- "; } }manzana -- banana -- cereza
$a = array("a" => "manzana", "b" => "banana");
$b = array("a" => "pera", "b" => "fresa", "c" => "cereza");
$d = array("c" => 2, "x" => "uva", "z" => "higo");Unión de $b y $a:
$c = $b + $a; // Unión de $b y $a foreach($c as $val2){ if($val2 === "cereza"){ // Si son identicos echo $val2; }else{ echo $val2 . " -- "; } }pera -- fresa -- cereza
$a = array("a" => "manzana", "b" => "banana");
$b = array("a" => "pera", "b" => "fresa", "c" => "cereza");
$d = array("c" => 2, "x" => "uva", "z" => "higo");Unión de $b y $d:
$c = $b + $d; // Unión de $b y $d foreach($c as $val3){ if($val3 != "higo"){ // Si hay desigualdad echo $val3 . " -- "; }else{ echo $val3; } }pera -- fresa -- cereza -- uva -- higo
$a = array("a" => "manzana", "b" => "banana");
$b = array("a" => "pera", "b" => "fresa", "c" => "cereza");
$d = array("c" => 2, "x" => "uva", "z" => "higo");Unión de $d y $a:
$c = $d + $a; // Unión de $d y $a // Si hay desigualdad if($a <> $b){ foreach($c as $val4){ if($val4 !== "banana"){ // Si no son identicos echo $val4 . " -- "; }else{ echo $val4; } } }2 -- uva -- higo -- manzana -- banana
Un Array bidimensional es un Array dentro de otro Array.
// Matriz escalar de dos dimensiones creada con array $biArray = array( array("Alemania", "Berlín", 557046, 78420000), array("Austria", "Viena", 83849, 7614000), array("Bélgica", "Bruselas", 30518, 9932000) ); // Esto es lo mismo que haber hecho esto: // fila 0 $biArray2 [0] [0] = "Alemania"; $biArray2 [0] [1] = "Berlín"; $biArray2 [0] [2] = 557046; $biArray2 [0] [3] = 7842000; // fila 1 $biArray2 [1] [0] = "Austria"; $biArray2 [1] [1] = "Viena"; $biArray2 [1] [2] = 83849; $biArray2 [1] [3] = 7614000; // fila 2 $biArray2 [2] [0] = "Bélgica"; $biArray2 [2] [1] = "Bruselas"; $biArray2 [2] [2] = 30518; $biArray2 [2] [3] = 9932000; // Matriz asociativa de dos dimensiones creada con array $biArray = array( "Alemania" => array( "Capital" => "Berlín", "Extensión" => 557046, "Habitantes" => 78420000 ), "Austria" => array( "Capital" => "Viena", "Extensión" => 83849, "Habitantes" => 7614000 ), "Bélgica" => array( "Capital" => "Bruselas", "Extensión" => 30518, "Habitantes" => 9932000 ) ); // Es lo mismo que hacer esto: $biArray["Alemania"]["Capital"] = "Berlín"; $biArray["Alemania"]["Extensión"] = "557056"; $biArray["Alemania"]["Habitantes"] = "78420000"; $biArray["Austria"]["Capital"] = "Viena"; $biArray["Austria"]["Extensión"] = "83849"; $biArray["Austria"]["Habitantes"] = "7614000"; $biArray["Bélgica"]["Capital"] = "Bruselas"; $biArray["Bélgica"]["Extensión"] = "30518"; $biArray["Bélgica"]["Habitantes"] = "9932000"; // RECORREMOS EL ARRAY echo "<table class="general">"; // Encabezado echo "<thead> <tr> <th>PAÍS</th> <th>CAPITAL</th> <th>EXTENSIÓN</th> <th>HABITANTES</th> </tr> </thead>"; echo "<tbody>"; foreach($biArray as $clave1 =>; $algo){ echo "<tr>"; echo "<th>" . $clave1 . "</th>"; foreach($algo as $clave2 => $valor1){ echo "<td>" . $valor1 . "</td>"; } echo "</tr>"; } echo "</tbody>"; echo "</table>";
Array dimensión 2
| PAÍS | CAPITAL | EXTENSIÓN | HABITANTES |
|---|---|---|---|
| Alemania | Berlín | 557056 | 78420000 |
| Austria | Viena | 83849 | 7614000 |
| Bélgica | Bruselas | 30518 | 9932000 |
Una expresión entre paréntesis con un operador de comparación (==) devuelve true o false, y confirma su igualdad cierta o falsa. Con el operador (!=) confirmaremos desigualdades.
Definimos 3 Arrays diferentes y confirmaremos igualdades con los operadores (== o !=)
$compA = array('asno', 'burro', 'mulo');
$compB = array(4, 14, 24);
$compC = array('asno', 'burro', 'mulo');
var_dump($compA == $compB); // Al no tener igualdades es "false"
var_dump($compA == $compC); // Al tener igualdades es "true"
var_dump($compB != $compC); // Al ser diferentes es "true" Comparamos 3 Arrays
0/ Comparamos Array 1o con el 2o con operador (==)
1/ Comparamos Array 1o con el 3o con operador (==)
1/ Comparamos Array 2o con el 3o con operador (!=)
Contamos todos los elementos de un array o en un objeto con el método count()
Cuenta con dos parámetros:
var: Array u Objetos.
mode: Si el parámetro opcional mode está definido con la constante COUNT_RECURSIVE (o 1), count() contará el array de forma recursiva. Esto es particularmente útil para contar todos los elementos de un array multidimensional.
$cuenta = array('fruits' => array('orange', 'banana', 'apple'),
'veggie' => array('carrot', 'collard', 'pea')
);
// Cuenta recursiva
echo count($cuenta, COUNT_RECURSIVE); // muestra 8
// Cuenta normal
echo count($cuenta); // muestra 2 Cuenta recursiva: 8
Cuenta normal: 2
$deporte = array ('Baloncesto', 'Futbol', 'Tenis', 'Natación'); // 4 elementos
echo "La matriz $deporte contiene: " . count($deporte); // Resultado 4 La matriz $deporte contiene: 4 elementos.
Funciones de PHP útiles para contar elementos de una matriz, a la que toma como un argumento y devuelve los elementos que contiene. count() acepta como parámetro cualquier tipo de variable, pero su verdadera utilidad es con las matrices ya que en
caso contrario siempre devuelve el valor 1.
El siguiente código cuenta las líneas que contiene un determinado archivo.php.
$archivo = "VarConsOeradores.php"; // Archivo.php. $lineas = file($archivo); // Crear una instáncia del archivo con "file". Almacenamos // el resultado en "$lineas" que será una matriz de líneas. $contar = count($lineas); // Contamos las líneas de la matriz "$lineas" mediante "count()". // Mostrar el resultado almacenado en esta variable => ($contar). echo ($contar);
La función count() toma una matriz como un argumento y devuelve el número de líneas que encuentra en él.
Número de líneas del archivo 'VarConsOeradores.php' ==> 457 líneas
Array de dimensión 2
Es un array que dentro tiene otro array. Este, a su vez, puede tener otro array y así sucesivamente, esto se denomina dimensión al nivel de anidamiento o de inclusión de arrays que se alcanza. Así que un array multidimensional de dimensión 2 está compuesto por un array que dentro tiene otros arrays y estos últimos, ya no contienen más arrays.
$profesiones = array (
array('Martos Sanabria', '25', 'Policia Nacional', '350000'),
array('Gines Giménez', '45', 'Sastre, confeccionista', '750000'),
array('Carla Pons', '37', 'Comercial, oficinista', '1050000')
);
// Acceder a los Arrays y sus elementos o celdas, por la nomenclatura de índices:
// Primero accedemos al array "$profesiones", seguidamente
// accedemos al primer array que está dentro del array
// "$profesiones" por su índice de arrays; y luego accedemos
// al elemento de ese array por su índice de elementos.
// [0][0] => primer array, primer elemento.
// [1][3] => segundo array, cuarto elemento.
// Haremos lo mismo para acceder a cualquier array y sus elementos.
// Muestra del primer array, los índices 0 y 3
echo $profesiones[0][0] . "Bruto anual " . $profesiones[0][3]";
// Muestra del segundo array, los índices 0 y 3
echo $profesiones[1][0] . "Bruto anual " . $profesiones[1][3]";
// Muestra del tercer array, los índices 0 y 3
echo $profesiones[2][0] . "Bruto anual " . $profesiones[2][3]"; Martos SanabriaBruto anual 35000
Gines GiménezBruto anual 22000
Carla PonsBruto anual 28500
$compra = array(
array('Titulo' => "ROSA", 'Precio' => 1.25, 'Numero' => 14),
array('Titulo' => "MARGARITA", 'Precio' => 0.75, 'Numero' => 21),
array('Titulo' => "ORQUIDEA", 'Precio' => 1.15, 'Numero' => 7)
);
// Mostrar estructura de tabla
echo "<table>";
echo "<thead>
<tr>
<th colspan="3">FLORISTERIA</th>
</tr>";
"<tr>
<td></td>
<td>COSTES</td>
<td>CANTIDAD</td>
</tr>
</thead> ";
echo "<tbody>";
echo "<tr>";
for ($fila = 0; $fila < 3; $fila++){
echo "<td>" . $compra[$fila]["Titulo"] . "</td>" .
"<td> " . $compra[$fila]["Precio"] . "</td>" .
"<td> " . $compra[$fila]["Numero"] . "</td>";
echo "</tr>";
}
echo "</tbody>";
echo "</table>"; | FLORISTERIA | ||
|---|---|---|
| COSTES | CANTIDAD | |
| ROSA | 1.25 | 14 | MARGARITA | 0.75 | 21 | ORQUIDEA | 1.15 | 7 |
Arrays asociativos son los que tienen claves de tipo caracter o cadena de caracteres. En este tipo de Arrays accederemos al Array dentro del Array por la nomenclatura de índices y acederemos a los elementos mediante el nombre de la CLAVE que se haya indicado, (nombre o equipo).
// Array asociativo $equipo = array ( array('nombre' => 'Lionel Messi', 'equipo' => 'Barcelona' ), array('nombre' => 'Cristiano Ronaldo', 'equipo' => 'Real Madrid' ), array('nombre' => 'Sergio Saturno', 'equipo' => 'Boca Juniors' ), array('nombre' => 'Neymar', 'equipo' => 'Santos' ), ); // Acceder a los Arrays y elementos (clave, valor) de Arrays asociativos: // Primero accedemos al array "$equipo", seguidamente // acceder al array dentro del array "$equipo", para después poder // acceder a la CLAVE, mediante el "nombre de clave" (nombre o equipo). echo $equipo[0]['nombre'] . ". Su equipo: " . $equipo[0]['equipo']; echo $equipo[1]['nombre'] . ". Su equipo: " . $equipo[1]['equipo']; echo $equipo[2]['nombre'] . ". Su equipo: " . $equipo[2]['equipo']"; echo $equipo[3]['nombre'] . ". Su equipo: " . $equipo[3]['equipo']";
Lionel Messi---------> Su equipo: Barcelona
Cristiano Ronaldo--> Su equipo: Real Madrid
Sergio Saturno-----> Su equipo: Boca Juniors
Neymar-------------> Su equipo: Santos
Recorrer Array multidimensional con bucle for mediante índices numéricos
Utilizar "$fila" para el array que contiene los arrays.
Utilizar "$col" para los arrays de dentro del array.
La variable "$fila" indicará la fila y la variable "$col" la columna.
Iniciamos la cuenta desde "0", e incrementamos esta, hasta llegar a la cantidad de elementos "-1".
Utilizamos "count" para contar la cantidad de elementos del array.
Para el for interior (dentro del otro for), también iniciamos la cuenta desde "0" e incrementamos en "1", y contará hasta la cantidad total de elementos del array "$empleados[$fila]".
$profesiones = array (
array('Martos Sanabria', '25', 'Policia Nacional', '350000'),
array('Gines Giménez', '45', 'Sastre, confeccionista', '750000'),
array('Carla Pons', '37', 'Comercial, oficinista', '1050000')
);
// Recorrer fila array.
for ($fila = 0; $fila <= count($profesiones)-1; $fila++) {
// Recorrer columna array.
for($col = 0; $col <= count($profesiones[$fila])-1; $col++){
// Si columna es igual a índice 3 (cuarta columna) ...
if($col == 3){
// muestra los elementos de la cuarta columna
// pero sin el guión final.
echo $profesiones[$fila][$col];
}else{
// Muestra los elementos de cada Array por filas.
echo $profesiones[$fila][$col] . ' - ';
}
}
echo '<br />';
}Recorrer Array escalar con for con índices no consecutivos
// Índices no consecutivos
$arrayPais = array(1 => "Alemania", "Austria", 5 => "Bélgica");Si evaluamos un Array con índices no consecutivos, como el anterior, con la función count() dentro de un bucle for, perderemos elementos del Array ya que count() devuelve 3 índices, y tenemos un índice 5 en el elemento "Bélgica", así que este elemento no existirá en el recorrido de for, porque count() solo devuelve hasta el índice 3.
foreach() es la opción adecuada para cuando sabemos que los índices o claves no son consecutivos; e incluso se pueden combinar valores escalares y asociativos en la definición de la matriz.
// Array de dimensión 2
$profesiones = array (
array('Martos Sanabria', '25', 'Policia Nacional', '35000'),
array('Gines Giménez', '45', 'Sastre, confeccionista', '22000'),
array('Carla Pons', '37', 'Comercial, oficinista', '28500')
);
for ($fila = 0; $fila <= count($profesiones)-1; $fila++) {
for($col = 0; $col <= count($profesiones[$fila])-1; $col++){
if($col == 3){
echo $profesiones[$fila][$col];
}else if($col == 1){
echo $profesiones[$fila][$col] . " - ";
}else{
echo $profesiones[$fila][$col] . " - ";
}
}
echo "<br />";
} Martos Sanabria - 25 - Policia Nacional - 35000No podemos usar for con índices asociativos, Ya que las claves de los elementos son de tipo cadenas tanto caracteres como números desordenados, nunca como números enteros ordenados.
En el caso de que el primer índice sea numérico, utilizaremos un bucle for externo, pero para el bucle interno, se debe utilizar foreach.
$profesiones = array (
array('Martos Sanabria', '25', 'Policia Nacional', '350000'),
array('Gines Giménez', '45', 'Sastre, confeccionista', '750000'),
array('Carla Pons', '37', 'Comercial, oficinista', '1050000')
);
for($arAsocia = 0; $arAsocia <= count($profesiones)-1; $arAsocia++){
// Recorre cada array "$profesiones" para recorrer
// cada uno de sus elementos pasados a "$clave".
foreach ($profesiones[$arAsocia] as $clave){
echo $clave . ' - ';
}
echo '<br />';
}Martos Sanabria - 25 - Policia Nacional - 35000 - Se puede explicar de la siguiente manera:
["audi"] seria la tabla que contiene los otros Arrays (filas y columnas).
["bmw"] seria otra tabla que contiene otros Arrays (filas y columnas).
["a3"] y ["z3"] serian las filas que contienen otro Array (columnas).
["2008"], últimos datos, serian otro Array (columnas).
Y cada tabla con su dato de fila y columna corresponde a un valor (20000).
$coches["audi"]["a3"]["2008"] = 20000; $coches["audi"]["a3"]["2010"] = 25000; $coches["audi"]["a3"]["2013"] = 50000; $coches["audi"]["a4"]["2005"] = 55000; $coches["bmw"]["z3"]["2013"] = 155000; // Sacar por pantalla el array tridimensional en formato de "lista" echo "<ul>"; // Recorrer dimensión 1 (tablas) foreach($coches as $tabla => $marca){ // Muestra nombre de la tabla echo "<li>". $tabla ."</li>"; // Abrir "lista anidada 1" echo "<ul>"; // Recorrer dimensión 2 (filas) foreach($marca as $fila => $modelo){ // Muestra nombre de la fila echo "<li>". $fila . "</li>"; // Abrir "lista anidada 2" echo "<ul>"; // Recorrer dimensión 3 (columnas) foreach($modelo as $colum => $anio){ // Muestra valor de la columna echo "<li>" . $colum . "</li>"; } // Cerrar "lista anidada 2" echo "</ul>"; } // Cerrar "lista 1" echo "</ul>\; } // Cerrar "lista" echo "</ul>";
// Índices escalares y asociativos, Array mixto
$arrayPais = array(1 => "Alemania", 2 => "Austria", país => "Bélgica");Es cuando uno de los Arrays es escalar (números en las claves) y el otro es asociativo (carácteres en las claves).
$arr1[ ][ ] = "Colum 0"; # ahora pondremos cero como indice del primer array y dejemos que PHP # nos vaya insertando automaticamente el segundo $arr1[0][ ] = "0.1"; $arr1[0][ ] = "0.2"; $arr1[0][ ] = "0.3"; $arr1[0][ ] = "0.4"; $arr1[0][ ] = "0.5"; #ahora desde [1][0] hasta [1][5] #este primero lo dejamos como automático en ambos indices # de esta forma el primero tomará valor uno (siguiente al anterior) # de forma automática $arr1[ ][ ] = "1.0"; # repetimos el proceso anterior $arr1[1][ ] = "Colum 1"; $arr1[1][ ] = "1.2"; $arr1[1][ ] = "1.3"; $arr1[1][ ] = "1.4"; $arr1[1][ ] = "1.5"; #ahora desde [2][0] hasta [2][5] # y repetimos de nuevo, ahora crearia 2 como primer indice $arr1[ ][ ] = "2.0"; #insertariamos los restantes valores de indice 2 $arr1[2][ ] = "2.1"; $arr1[2][ ] = "Colum 2"; $arr1[2][ ] = "2.3"; $arr1[2][ ] = "2.4"; $arr1[2][ ] = "2.5"; # nuevo incremento del primer indice #ahora desde [3][0] hasta [3][5] $arr1[ ][ ] = "3.0"; # rellenamos $arr1[3][ ] = "3.1"; $arr1[3][ ] = "3.2"; $arr1[3][ ] = "Colum 3"; $arr1[3][ ] = "3.4"; $arr1[3][ ] = "3.5"; # nuevo y ultimo incremento de primer indice #ahora desde [4][0] hasta [4][5] $arr1[ ][ ] = "4.0"; # rellenamos $arr1[4][ ] = "4.1"; $arr1[4][ ] = "4.2"; $arr1[4][ ] = "4.3"; $arr1[4][ ] = "Colum 4"; $arr1[4][ ] = "4.5"; #ahora desde [5][0] hasta [5][5] $arr1[ ][ ] = "5.0"; # rellenamos de nuevo $arr1[5][ ] = "5.1"; $arr1[5][ ] = "5.2"; $arr1[5][ ] = "5.3"; $arr1[5][ ] = "5.4"; $arr1[5][ ] = "Colum 5"; // CREACIÓN DE TABLA ----------------- # Introducimos un bucle para mostrar en una # tabla todos los datos del Array. # creamos la etiqueta de apertura de una tabla print ("<table class="tablearraymixto" border = 2>"); # ahora dos bucles anidados (rojo uno, magenta el otro) # para rellenar las celdas de cada fila (el magenta) # y para insertar las etiquetas <tr> utilizaremos el rojo echo "<thead>"; echo "<tr>"; echo "<th colspan="6">Datos de Array en tabla</th>"; // 2º TH echo "<tr>"; echo "<th colspan="2">COLUMNAS 1 y 2</th>"; echo "<th colspan="2">COLUMNAS 3 y 4</th>"; echo "<th colspan="2">COLUMNAS 5 y 6</th>"; echo "</tr>"; echo "</tr>"; echo "</thead>"; echo "<tbody>"; // Recorremos los Arrays (filas) for ($fila = 0; $fila < 6; $fila++){ echo("<tr>"); // Creamos un "tr". // Recorremos los elementos de cada Array (td). for($columna = 0; $columna < 6; $columna++){ // Insertamos los elementos (td) en sus filas (tr). echo("<td>" . $arr1[$fila][$columna] . "</td>"); } } echo "</tbody>"; #ponemos la etiqueta de cierre de la tabla echo ("</table>");
| Datos de Array en tabla | |||||
|---|---|---|---|---|---|
| COLUMNAS 1 y 2 | COLUMNAS 3 y 4 | COLUMNAS 5 y 6 | |||
| Colum 0 | 0.1 | 0.2 | 0.3 | 0.4 | 0.5 |
| 1.0 | Colum 1 | 1.2 | 1.3 | 1.4 | 1.5 |
| 2.0 | 2.1 | Colum 2 | 2.3 | 2.4 | 2.5 |
| 3.0 | 3.1 | 3.2 | Colum 3 | 3.4 | 3.5 |
| 4.0 | 4.1 | 4.2 | 4.3 | Colum 4 | 4.5 |
| 5.0 | 5.1 | 5.2 | 5.3 | 5.4 | Colum 5 |
| Datos de Array en tabla | |||||
|---|---|---|---|---|---|
| COLUMNAS 1 y 2 | COLUMNAS 3 y 4 | COLUMNAS 5 y 6 | |||
| 0 | 0.1 | 0.2 | 0.3 | 0.4 | Fila 0 |
| 1 | 1.1 | 1.2 | 1.3 | 1.4 | Fila 1 |
| 2 | 2.1 | 2.2 | 2.3 | 5.4 | Fila 2 |
| 3 | 3.1 | 3.2 | 3.3 | 3.4 | Fila 3 |
| 4 | 4.1 | 4.2 | 4.3 | 4.4 | Fila 4 |
| 5 | 5.1 | 5.2 | 5.3 | 5.4 | Fila 5 |
print_r() que utiliza como argumento cualquier tipo de dato y lo imprime, al funcionar de modo recursivo si el argumento es una matriz imprimiriá todos los elementos.
print_r($nombreArray);
var_dump(): nos permite visualizar más detalles sobre os datos: tipo y tamaño.
var_dump($nombreArray);
"array_slice(), array_shift(), array_pop()
array_slice(): Esta función reduce el tamaño de la matriz mediante tres parámetros:
$arrslice = array ('gráfica', 'disquetera', 'ventilador', 'microprocesador', 'discoduro', 'ram ddr2'); // Del array $arrslice devuelve los elementos que se encuentran // a partir del 3er índice excepto "-1" el último índice. $rslt = array_slice($arrslice, 3, -1); $contador = 0; foreach ( $rslt as $rslslice ) { $contador++; // Devuelve 'microprocesador' y 'discoduro' echo $contador . " " . $rslslice . "<br />"; }1/ microprocesador
// Del array $arrslice devuelve los elementos que se encuentran // a partir del 2o índice hasta el último, ya que se omite el 3er parámetro. $rslt1 = array_slice($arrslice, 2); $contador = 0; foreach( $rslt1 as $rslslice ) { $contador++; // Devuelve: 'ventilador', 'microprocesador', 'discoduro' y 'ram ddr2' echo "$contador . " " . $rslslice . "<br />"; }1/ ventilador
// Del array $arrslice devuelve los elementos que se encuentran // a partir del penúltimo índice, ya que es "-2" y el tercer parámetro indica 1 solo elemento. $rslt1 = array_slice($arrslice, -2, 1); $contador = 0; foreach( $rslt1 as $rslslice ) { $contador++; // Devuelve: 'discoduro' echo "$contador . " " . $rslslice . "<br />"; }1/ discoduro
// Del array $arrslice devuelve los elementos que se encuentran // a partir del 1er índice, ya que es "1" y el tercer parámetro indica 3 elementos a devolver. $rslt1 = array_slice($arrslice, 1, 3); $contador = 0; foreach( $rslt1 as $rslslice ) { $contador++; // Devuelve: 'disquetera', 'ventilador', 'microprocesador' echo "$contador . " " . $rslslice . "<br />"; }1/ disquetera
array_shift(): Esta función extrae solo el primer elemento del Array, desplazando el resto de los elementos hacia adelante y trabaja directamente sobre la matriz indicada (no devuelve una matriz nueva), Además, el elemento extraido queda almacenado en una variable.
La función array_shift permite implementar las listas de tipo colas (mecanismo FIFO: primero que entra, primero que sale).
$arrshift = array('gráfica', 'disquetera', 'ventilador', 'microprocesador', 'discoduro', 'ram ddr2'); // Contamos los elementos del array antes de extraer echo "Elementos del Array = " . count($arrshift); // Devuelve 6 $varAlmacenadashift = array_shift($arrshift); // Elimina el primer elemento echo "Primer elemento eliminado => " . $varAlmacenadashift; // Volver a mostrar los elementos restantes echo "Ahora el Array tiene = " . count($arrshift); // Devuelve 5
Elementos del Array = 6
Primer elemento eliminado => gráfica
Ahora el Array tiene = 5 elementos
Subirarray_pop(): Esta función extrae solo el último elemento del Array, devuelve una matriz nueva a partir de la matriz a la que se le a extraido el último elemento.
La función array_pop permite implementar pilas (mecanismo LIFO: último que entra, primero que sale).
$arrpop = array('gráfica', 'disquetera', 'ventilador', 'microprocesador', 'discoduro', 'ram ddr2'); echo "Elementos del Array => " . count($arrpop); foreach($arrpop as $valorpop){ echo $valorpop; } // Extraemos el último elemento $rslt3 = array_pop($arrpop); echo "Elemento extraido => " . $rslt3; echo "Ahora el Array tiene => " . count($arrpop) . " elementos"; // Volvemos a mostrar elementos después de extraer el último elemento foreach($arrpop as $valorpop){ echo $valorpop; }
Elementos del Array => 6
gráficadisqueteraventiladormicroprocesadordiscoduroram ddr2Elemento extraido => ram ddr2
Ahora el Array tiene => 5 elementos
gráficadisqueteraventiladormicroprocesadordiscoduroarray_push(): Esta función agrega elementos a un Array en forma de PILA, (añade elementos por la cola) y se devuelve un valor entero con los nuevos elementos agregados a la matriz.
Esta función eliminará elementos comunes cuando haya elementos con claves de cadena duplicadas (solo dejará el primer elemento leido).
$arrpush = array('gráfica', 'disquetera', 'ventilador', 'microprocesador', 'discoduro', 'ram ddr2'); echo "Vector original"; // Mostrar los elementos del Array // como una lista echo "<ol>"; foreach($arrpush as $valorpush){ echo "<li>" . $valorpush . "</li>"; } echo "</ol>"; // Cierro lista echo "Vector aumentado"; // Aumentar Array $aumentar = array_push($arrpush, "bios", "chipset"); // Volver a mostrar Array con los nuevos elementos // insertados al final del Array. Vemos como una lista echo "<ol>"; foreach($arrpush as $valoresNuevo){ echo "<li>" . $valoresNuevo . "</li>"; } echo "</ol>"; // Cierro lista
Vector original:
array_merge(): Con esta función podremos unir dos o más matrices. Utilizando como parámetros el nombre de las matrices a unir.
Los elementos se van añadiendo por la cola comenzando por la primera matriz colocada como primer parámetro.
Si hay dos o más elementos de un array que tienen la misma clave, el último elemento, prevalece sobre las demás.
Si se asigna una sola matriz a la función array_merge(), y las claves son números enteros, la función devuelve una nueva matriz con claves enteras comenzando en 0 e incrementandolas en 1 para cada valor. Si las matrices tienen claves numéricas no se elimina ningún elemento.
// Se omite la clave 'b', ya que se repite $perif1 = array("a" =>"impresora", "b" => "monitor"); // Predominará la última clave que se repita 'b'. $perif2 = array("c"=> "router", "b" => "teclado"); // Unir dos Arrays $arrmerge = array_merge($perif1, $perif2); // Recorrer array, sus claves y valores como una lista echo "<ul>"; foreach($arrmerge as $clavemerge => $valmerge) { echo "<li>" . $clavemerge . " -> " . $valmerge . "</li>"; } echo "</ul>"; // Cerrar lista
array_merge_recursive(): Esta función nos permite combinar una o más matrices y sin perder elementos, en una sola matriz. Va añadiendo las matrices una trás otra, devolviendo una nueva matriz como resultado.
Cuando se detecten claves de cadena duplicada, no sobreescribirá el valor del elemento, sino que generará una matriz con los valores.
// Combinamos 5 matrices
$mergeRecur1 = array("uno" => "Alemania");
$mergeRecur2 = array("dos" => "Francia", "uno" => "Italia");
$mergeRecur3 = array("dos" => "Francia", "tres" => "España");
$mergeRecur4 = array("UK", "Brasil");
$mergeRecur5 = array("Canadá", "Portugal", "Argentina");
// Se toman en cuenta las claves repetidas
$mergeRecur6 = array_merge_recursive($mergeRecur1, $mergeRecur2, $mergeRecur3,
$mergeRecur4, $mergeRecur5);
// Las claves "uno" y "dos" son ahora arrays dentro del array
echo "Contenido actual de la matriz = cantidad de elementos: " . $contar;
foreach($mergeRecur6 as $clave => $valor){
// Si el valor es un array
if(is_array($valor)):
// Recorrer sus elementos
foreach($valor as $clave1 => $valor1){
// Sacar los índices y sus valores
echo $clave . " __ " . $valor1 . "<br />";
}
else:
// Sacar el índice y su valor si no son un Array
echo $clave . " -- " . $valor . "<br />";
endif;
echo "<br />";
}
Contenido actual de la matriz = cantidad de elementos: 8
uno __ Alemania// Combinamos 5 matrices $mergeRecur1 = array("uno" => "Alemania"); $mergeRecur2 = array("dos" => "Francia", "uno" => "Italia"); $mergeRecur3 = array("dos" => "Francia", "tres" => "España"); $mergeRecur4 = array("UK", "Brasil"); $mergeRecur5 = array("Canadá", "Portugal", "Argentina"); // Se toman en cuenta las claves repetidas $mergeRecur6 = array_merge_recursive($mergeRecur1, $mergeRecur2, $mergeRecur3, $mergeRecur4, $mergeRecur5); // LISTA DE ARRAY MERGE_RECURSIVO echo "<ul>"; // Recorrer dimensión 1 foreach($mergeRecur6 as $clavemerRecur => $valmerRecur1){ echo "<li>" . $clavemerRecur . ' -> </li>'; // Comprovamos si el valor "$valmerRecur1" es un Array, es decir, si contiene (índices duplicado). if(is_array($valmerRecur1)): echo "<ul>"; // Abrir "lista anidada 1" // Recorrer dimensión 2 foreach($valmerRecur1 as $clave2 => $valmerRecur2){ // Muestra nombre de la fila echo "<li>" . $valmerRecur2 . "</li>"; } echo "<ul>"; // Cerrar "lista anidada 1" else: // En caso de no tener ningún índice duplicado echo "<ul><li>" . $valmerRecur1 . "</li></ul>"; endif; } // Cerrar "lista" echo "</ul>";
array_unshift(): Esta función es la inversa a array_shift(), que permite extraer el primer elemento del array. Pués bien con array_unshift() podemos añadir uno o más elementos por delante de la matriz, devolviendo la matriz actualizada con los nuevos elementos.
$arrunshift = array('gráfica', 'disquetera', 'ventilador', 'microprocesador', 'discoduro', 'ram ddr2'); $contador = 0; echo "Elementos del Array original: "; for($x = 0; $x <= count($arrunshift)-1; $x++){ // Mostrar elementos y un contador $contador++; echo $contador . " " . $arrunshift[$x] . "<br />"; } // Añadimos dos elementos por adelante con array_unshift() array_unshift($arrunshift, "bios", "chipset"); $contador = 0; echo "Elementos del nuevo Array: "; for($y = 0; $y <= count($arrunshift)-1; $y++){ // Mostrar array con los nuevos elementos y un contador $contador++; echo $contador . " " . $arrunshift[$y] . "<br />"; }
Elementos del Array original:
1/ gráficaElementos del nuevo Array:
1/ biosarray_pad(): Esta función nos permite añadir al array elementos de relleno (valores constantes), tanto al inicio como al final de la matriz.
El relleno al inicio se producirá con números positivos.
El relleno al final se producirá con números negativos.
Si el valor absoluto del tamaño de relleno es menor o igual a la longitud de la entrada entonces no se produce rellenado.
$arrpad = array('gráfica', 'disquetera', 'ventilador', 'microprocesador', 'discoduro', 'ram ddr2' ); // Añadir elementos de relleno constantes // por la cola, hasta llegar a 8 elementos. $arrpad2 = array_pad( $arrpad, 8, 'RATÓN' ); echo "Relleno por la cola: "; $contador = 0; for($r = 0; $r <= count($arrpad2)-1; $r++){ $contador++; if($r == 6){ // Si índice es el '6', colocamos un guión echo $contador . " " . $arrpad2[$r] . " -- "; } else if($r == 7){ // Si índice es el '7' // Último elemento sin guión echo $contador . " " . $arrpad2[$r]; }else{ echo $contador . " " . $arrpad2[$r] . " -- "; } }
Relleno por la cola:
1gráfica -- 2disquetera -- 3ventilador -- 4microprocesador -- 5discoduro -- 6ram ddr2 -- 7 RATÓN -- 8 RATÓNArray de 8 elementos
$arrpad2 = array('gráfica', 'disquetera', 'ventilador', 'microprocesador', 'discoduro', 'ram ddr2', 'RATÓN', 'RATÓN' ); echo count($arrpad2); // añadir por adelante elementos de relleno constantes // hasta llegar a 9 elementos $arrpad3 = array_pad ($arrpad2, -10, 'ZÓCALO_CPU'); echo "Relleno por el inicio: "; $contador = 0; // Recorrer el array for($h = 0; $h <= count($arrpad3)-1; $h++){ $contador++; if($arrpad3[$h] == 'ZÓCALO_CPU'){ // Dos primeros elementos con guión echo $contador . " " . $arrpad3[$h] . " -- "; } else if($h == 9){ // Último elemento sin guión echo $contador . " " . $arrpad3[$h]; }else{ echo $contador . " " . $arrpad3[$h] . " -- "; } }
Relleno por el inicio:
1/ ZÓCALO_CPU -- 2/ ZÓCALO_CPU -- 3 gráfica -- 4 disquetera -- 5 ventilador -- 6 microprocesador -- 7 discoduro -- 8 ram ddr2 -- 9 RATÓN -- 10 RATÓNArray de 10 elementos
$arrpad3 = array('gráfica', 'disquetera', 'ventilador', 'microprocesador', 'discoduro', 'ram ddr2', 'RATÓN', 'RATÓN' ); echo count($arrpad3); // Indicamos un tamaño inferior al tamaño del Array '4' $arrpad4 = array_pad( $arrpad3, 2, "nuevo_elemento" ); // No habrá relleno, ya que el tamaño indicado en // función 'array_pad()' es menor al tamaño del array. $contador = 0; $tamanyo = count($arrpad4)-1; for($w = 0; $w <= count($arrpad4)-1; $w++){ 10++; if($tamanyo < 10){ echo "Se ha insertado un número inferior al tamaño del Array"; break; // Salimos del bucle }else{ echo $contador . " " . $arrpad4[$w] . " -- "; } }
Omitir el relleno:
Si el tamaño de relleno es menor o igual, se omite el relleno.
El array contiene 10 elementos.
Se ha insertado un número inferior al tamaño del Arrayarray_intersect(): Función para conocer los elementos en común que pueden haber entre dos Arrays. Como resultado obtendremos un Array con los elementos en común.
La comparación para la intersección no sólo compara valores, además compara la representación (string) del valor (comparación idéntica ===). En la comparación no se toman en cuenta las claves.
$arrinter1 = array("a" => "DO", "b" => "RE", "c" => "SOL", "d" => "FA"); $arrinter2 = array("e" => "DO", "f" => "SOL", "g" => "FA", "m" => "re"); // Sacar los elementos en común de estos dos arrays $rsltinter = array_intersect($arrinter1, $arrinter2); $contador = 0; echo "<ul>"; // Abrir lista echo "<li>Elementos en común de dos Arrays: </li>"; // Recorrer el array foreach($rsltinter as $valinter){ $contador++; // Incrementar contador echo "<li>" . $contador . ", " . $valinter . "</li>"; } echo "</ul>"; // Cerrar lista
Elementos en común de dos Arrays:
array_intersect_assoc(): Esta función hace intervenir a las claves y a los valores para la comparación. Debe haber coincidencia de orden y valor o en clave y valor.
Es decir compara dos o más Arrays para devolver una matriz con las claves y valores de la primera matriz, sólo si están presentes en todas las otras matrices.
// Tres Arrays $arrinterassoc1 = array("impresora", "chipset" , "bus_PCI", "ratón"); $arrinterassoc2 = array("555", "chipset", "teclado", "IMPRESORA"); $arrinterassoc3 = array("router", "chipset", "teclado", "monitor"); $rsltinterassoc = array_intersect_assoc($arrinterassoc1, $arrinterassoc2, $arrinterassoc3); echo "Elementos en común de los tres arrays:"; foreach($rsltinterassoc as $clainterassoc => $valinterassoc){ // El resultado es 'chipset' ya que en los // tres casos se encuentra en el mismo // índice y el valor es identico. echo $clainterassoc . " " . $valinterassoc; }
Elementos en común de los tres arrays:
1chipset
Subirarray_intersect_key(): Calcula la intersección de dos o más arrays usando las claves para la comparación.
El resultado es un Array con los elementos del primer array, de las claves que se repitan en todos los arrays comparados
// Arrays a comparar, por claves repetidas $arrinterkey1 = array('viernes' => 1, 'lunes' => 2, 'jueves' => 3, 'domingo' => 4); $arrinterkey2 = array('jueves' => 5, 'viernes ' => 6, 'sábado' => 7, 'miercoles' => 8); $arrinterkey3 = array('lunes' => 9, 'jueves' => 10, 'martes' => 11, 'viernes' => 12); // Recupero claves repetidas de arrays a comparar $rsltinterkey = array_intersect_key($arrinterkey1, $arrinterkey2, $arrinterkey3); foreach($rsltinterkey as $clave1 => $valinterkey){ echo $clave1 . " " . $valinterkey . "viernes 1
"; }
array_unique(): Elimina valores duplicados de un array, utilizando la comparación de igualdad (===), la matriz puede ser escalar o asociativa.
Es decir que devuelve un nuevo array sin valores duplicados. Si un elemento de la matriz es un tipo array, la igualdad sólo se daría si también existiese otro elemento array idéntico.
El método array_unique() no está pensado para funcionar en arrays multidimensionales.
$arrunique1 = array("jumppers", "webcam", "flopy");
// Un array dentro de otro es '1' elemento más,
// cuenta como '1' independientemente de los
// elementos que contenga ese array interior.
$arrunique2 = array( "a" => "discoduro", "gráfica", "b" => "discoduro",
"teclado", "gráfica", $arrunique1 );
// Eliminar los elementos duplicados
$rsltunique = array_unique($arrunique2);
echo "Sacar los elementos después de eliminar los que están duplicados";
echo "<ul>"; // Abrir lista
// Sacar elementos después de eliminar los duplicados
foreach($rsltunique as $clave => $valunique){
echo "<li>" . $clave . "/ " . $valunique . "</li>";
// Comprobar si '$valunique' algún valor es un Array
if(is_array($valunique)){
// Lista anidada
echo "<ul>";
// Si es un Array, lo recorre
foreach($valunique as $clave3 => $valunique2){
echo "<li>" . $clave3 . "/ " . $valunique2 . "</li>";
}
echo "</ul>"; // Cerrar lista anidada
}
}
echo "</ul>"; // Cerrar lista Sacar los elementos después de eliminar los que están duplicados
Eliminar los elementos duplicados (sin importar el tipo de dato)
// Eliminar los elementos duplicados (sin importar los tipos de datos) $arrunique3 = array(4, "4", "3", 4, 3, "3"); $rsltunique2 = array_unique($arrunique3); foreach($rsltunique2 as $clave1 => $valunique2){ // El resultado es 4 y 3 ya que se repite, sea de tipo cadena o de tipo numérico echo $clave1 . "/ " . $valunique2 . " "; }0/ 4
echo "array_unique() y tipos de datos"; // Eliminar los elementos duplicados (tipos) $notas = array(); $notas[0] = "DO"; $notas[1] = "DO"; $notas[2] = "DO"; $notas[3] = "RE"; $notas[4] = "DO"; $notas[5] = "RE"; $notas[6] = "MI"; $notas[7] = "RE"; $notas= array_unique($notas); $numValor = count($notas); for($n = 0 ; $n <= 7 ; $n++){ // Si elemento vacio ... if(empty($notas[$n])){ // Texto para campos duplicados echo "notas " . $n . " = Campo duplicado "; }else{ // Resultado: DO, RE, MI echo("notas " . $n . " = " . $notas[$n] . " "); } } echo "Número de elementos en Array notas = " . $numValor; // Resultado: 3
array_unique() y tipos de datos
notas 0 = DONúmero de elementos en Array notas =3
Subircompact(): Podemos crear una matriz a partir de nombres de variables, dentro del ámbito vigente. El nuevo Array, tendrá tantos elementos como variables tengamos como parámetros dentro de la función (puede contener una matriz como parámetro), la clave de cada elemento será el nombre de su variable. Hace lo contrario que la función extract().
$Apellidos = "Barcelona";
$Nombre = "Badalona";
$Edad = "AAEEZZCC";
$arrdatos = array("Apellidos", "Nombre");
// Crear matriz a partir de nombres de variables
// Las variables que no existan, las omite.
$rsltcompact = compact("Edad", "var_inexistente", $arrdatos);
// El nombre de la variable será el nombre de la CLAVE
foreach($rsltcompact as $clacompact => $valcompact){
echo $clacompact . " -> " . $valcompact . "<br />";
}Crear matriz a partir de nombres de variables
Los nombres de variables que no encuentra, las omite.
extract(): Esta función es la opuesta a compact(), toma como argumento una matriz asociativa y crea las variables en base a las claves de los elementos y les asigna los valores correspondientes en base al valor de cada uno de los elementos.
Un array indexado numéricamente no producirá resultados a menos que se use EXTR_PREFIX_ALL o EXTR_PREFIX_INVALID.
Esta operación puede tener ciertas incidencias, por ejemplo el nombre que le corresponde a la nueva variable podría ser ilegal, en ese caso ese elemento no se toma en cuenta. Además esa operación puede encontrarse con colisiones de nombres de variables ya existentes en el ámbito vigente, esto lo resolveremos incluyendo estas operaciones:
Si no se especifica extract_type, se asume que es EXTR_OVERWRITE.
// Se supone que $var_arrext es un array devuelto desde bis_deserializar $tamanyo = "enorme"; $var_arrext = array("color" => "azul", "tamanyo" => "standar", "forma" => "circular"); // Extraer mismo prefijo (no sobre-escribe 'tamanyo') extract($var_arrext, EXTR_PREFIX_SAME, "bis"); echo "$color - $tamanyo - $forma - $bis_tamanyo\";
azul - enorme - circular - standar
El $tamanyo no se ha sobrescrito ya que se especificó EXTR_PREFIX_SAME, lo que resulta en la creación de $bis_tamanyo. Si se hubiera especificado EXTR_SKIP, $bis_tamanyo no se habría creado. EXTR_OVERWRITE causaría que $tamanyo tuviera el valor "standar", y EXTR_PREFIX_ALL resultaría en variables nuevas llamadas $bis_color, $bis_tamanyo, y $bis_forma.
compact(): Una operación casi siempre frecuente cuando se trabaja con matrices para el almacenamiento y recuperación de datos, es la navegación secuencial a traves de todos los elementos de la matriz, o por lo menos hasta que alguna condición se cumpla.
foreach es una herramienta principalmente para trabajar con arrays tanto de tipo escalar como asociativo.
Existe un grupo de funciones especiales de navegación para tratar con matrices no secuenciales; (estas funciones también podremos aplicarlas a matrices secuenciales).
$arrsecuen0 = array("Color" => "Azul", "Altura" => "2 metros", "Ancho" => 1.15, "Peso" => 105); // Fuerza el posicionamiento al inicio de la matriz // (en este caso sería innecesario) reset($arrsecuen0); echo "Atributos: "; echo key($arrsecuen0). "<br />"; // next() devuelve False al llegar al último elemento) while (next($arrsecuen0)) echo key($arrsecuen0). "<br />"; // posicionarse en el final de la matriz end($arrsecuen0); echo "Valores en orden inverso con prev(): <br />"; echo current($arrsecuen0). "<br />"; // Navegación hacia atrás // prev() devuelve false al llegar al principio del archivo while (prev($arrsecuen0)) echo current($arrsecuen0) . "<br />"; // vuelve a posicionar el puntero interno de la matriz reset($arrsecuen0); echo "Navegación con each(): "; // each() devuelve una matriz de cuatro elementos por cada // elemento de la matriz $arrsecuen0 // en el elemento 0 está la clave // en el elemento 1 está el valor // $temp es una matriz temporal while ($temp = each($arrsecuen0)) echo $temp[0] . " : " . $temp[1] . "<br />";
funciones: reset, next, prev, end, current, key, each
Atributos: devuelve la clave con key()
ColorValores en orden inverso con prev():
105Navegación con each(): devuelve valor y clave