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
Color : AzulEsta función aplica una determinada función de usuario a toda una matriz en una única llamada. array_walk() pasa a la función de usuario el elemento de la matriz, su clave y dato adicional de usuario de manera sucesiva y automática.
array_walk() recorrerá el array completo sin tener en cuenta la posición del puntero.
$frutas = array("d" => "limón", "a" => "naranja", "b" => "banana", "c" => "manzana"); // Parámetros: '&$elemento1' = variable por referencia // mantiene la ruta de la variable, no la copia de su valor function otro_text(&$elemento1, $clave, $prefijo){ // $prefijo = clave, $elemento1 = su valor $elemento1 = "$prefijo -> $elemento1"; } function imprime_text($elemento2, $clave){ // $clave = clave, $elemento2 = su valor echo "$clave -> $elemento2<br />"; } // Aplicamos la función y su clave y dato adicional // '$frutas' es la matriz a aplicar la función, // 'imprime_text' es la llamada a la función. array_walk($frutas, 'imprime_text'); // Aplicamos la función y su clave y dato adicional // '$frutas' es la matriz a aplicar la función, // 'fruta' seria el nombre entre la clave y el valor, // 'otro_text' es la llamada a la función. array_walk($frutas, 'otro_text', 'fruta'); // Volvemos a llamar la función con sus claves y // datos después de pasarle la función 'otro_text'. array_walk($frutas, 'imprime_text')";
array_walk($nombreArray, nombreFunción)
d -> limón
a -> naranja
b -> banana
c -> manzana
array_walk($nombreArray, nombreFunción, nombreClave)
d -> fruta -> limón
a -> fruta -> naranja
b -> fruta -> banana
c -> fruta -> manzana
// Pasar dos parámetros a función function disenyo($valor, $clave){ echo "La clave " . $clave . " tiene el valor " . $valor . " <br />"; } // Array con 2 claves y dos valores $rsltwalk = array("1/" => "Photoshop", "2/" => "Flash"); // Aplicamos la función a la matriz '$rsltwalk' array_walk($rsltwalk, "disenyo");La clave 1/ tiene el valor "Photoshop"
// matriz asociativa $arrwalk2 = array("Color" => "Rojo", "Altura" => 1.80, "Ancho" => 2.50, "Peso" => 127); // función para tratar a todos los elementos // '$valor' es el valor del elemento // '$clave' es la propia clave // '$dato' corresponde al mensaje de error. function tratar ($valor, $clave, $dato){ switch($clave){ case "Color": // clave 1 $valor = "color $valor"; // Rojo break; case "Altura": // clave 2 $valor = "alto $valor metros"; // 1.8 break; case "Ancho": // clave 3 $valor = "ancho $valor metros"; // 2.5 break; case "Peso": // clave 4 $valor = "peso $valor kilos"; // 127 break; default: // '$dato' es el tercer parámetro de la función, así que // mostrara el tercer parámetro pasado desde 'array_walk()'. $valor = "$valor $dato"; } echo $valor . "<br />"; } // La arroba es para separar elementos? // El método '$arrwalk2' tiene 3 parámetros: // el array, la llamada a la función y un mensaje // de texto 'clave no esperada' por si hay error en la sentencia 'switch' @array_walk($arrwalk2, 'tratar', 'clave no esperada');
color Rojo
alto 1.8 metros
ancho 2.5 metros
peso 127 kilos
Podriamos crear una matriz a partir de algunos elementos de otra matriz, mediante foreah recorreriamos la matriz seleccionando algunos elementos en base a unos criterios de selección, verificando cada elemento para saber si cumplen el criterio o no para incorporarlos a la nueva matriz. Esto supondria escribir varias líneas de código, pero PHP dispone de unas funciones con las que podemos reducir esas líneas de código a una sola línea:
// Devuelve todos los elementos de la matriz // que contienen números de coma (punto) flotante. $matriz_fl = preg_grep("/^(\d+)?\.\d+$/", $matriz);
$array = array(0 => 'azul', 1 => 'rojo', 2 => 'verde', 3 => 'rojo');
$clave = array_search('verde', $array); // $clave = 2;
$clave = array_search('rojo', $array); // $clave = 1; // Buscar elemento por su valor $estaelemento = array('acheteemeele' => 'HTML', 'peachepe' => 'PHP', 'ceeseese' => 'CSS'); echo "Está el elemento PHP" . in_array('PHP', $estaelemento); // Devuelve 1
// Buscar elemento por su clave $estaelemento = array('acheteemeele' => 'HTML', 'peachepe' => 'PHP', 'ceeseese' => 'CSS'); echo "Está el elemento peachepe" . array_key_exists('peachepe', $estaelemento); // Devuelve 1
Ejemplos de las 4 funciones:
preg_grep()
// Array para el ejemplo $arrbuselem = array('Samuel', 'Alberto', '5' => 'Pedro', 'Anna', 'Esteban'); // Busca todos los elementos que empiecen por "A" $rsltpregrep = preg_grep("/^A/", $arrbuselem); foreach($rsltpregrep as $clapregrep => $valpregrep){ echo $clapregrep . " " . $valpregrep . "
"; }
Resultado con la función preg_grep()
1 Albertoarray_search()
// Array para el ejemplo $arrbuselem = array('Samuel', 'Alberto', '5' => 'Pedro', 'Anna', 'Esteban'); // Comprobar la clave de un determinado elemento en un Array $clavesearch = array_search("Samuel", $arrbuselem); // respuesta = 0 echo "La clave de Samuel es: " . $clavesearch . "<br />"; $clavesearch = array_search("Gerard", $arrbuselem); // respuesta = Vacio (no está) echo "La clave de Gerard es: " . $clavesearch . "<br />"; $clavesearch = array_search("Pedro", $arrbuselem); // respuesta = 5 echo "La clave de Pedro es: " . $clavesearch . "<br />";
Resultado con la función array_search()
La clave de Samuel es: 0in_array()
// Array para el ejemplo $arrbuselem = array('Samuel', 'Alberto', '5' => 'Pedro', 'Anna', 'Esteban'); // Confirmar si está el elemento "Pedro" en Array $rsltinarray = in_array("Pedro" ,$arrbuselem); if($rsltinarray = true){ // Si está echo $rsltinarray . " Pedro está como valor."; }else{ // Si no está echo $rsltinarray . " No está como valor."; }
Resultado con la función in_array()
1Pedro está como valorarray_key_exists()
// Array para el ejemplo $arrbuselem = array('puerto_serie' => 1, 'perto_VGA' => 4, 'puerto_USB' => '6', 'puerto_red_LAN' => '8'); // Verifica si el índice o clave dada existe en el array if (array_key_exists('puerto_USB', $arrkeyexists)): echo "La clave 'puerto_USB' está en este Array"; else: echo "La clave 'puerto_USB' no está en este Array"; endif;
Resultado con la función array_key_exists()
La clave 'puerto_USB' está en este ArrayUna forma de agregar un nuevo elemento a un Array es definiendo la clave con el operador [ ] y su valor, la clave puede ser numérica o de cadena, o bien no tener clave, en ese caso, PHP busca la clave numérica más alta y asignará para la nueva clave el siguiente índice de clave, es decir PHP busca el índice más alto que podría ser [8], y asigna [9] para el nuevo índice de clave.
$colores = array (3 => 'rojo', 1 => 'amarillo', 'otrocolor' => 'beig'); $colores[ ] = "AZUL"; // Clave sin índice, que PHP le asignará el último índice [4] $colores[0] = "VERDE"; // Clave índice '0' echo "Elemento escalar, índice 4 => " . $colores[4]; echo "Elemento escalar, índice 0 " . $colores[0]; echo "Elemento asociativo, índice otrocolor => " . $colores['otrocolor'];
Elemento escalar, índice 4 => AZUL
Elemento escalar, índice 0 => VERDE
Elemento asociativo, índice otrocolor beig
Para eliminar elementos de un Array, precisamos de la función unset().
unset(): para eliminar cualquier elemento de un Array ecribimos entre los paréntesis el nombre del Array y la clave que se desea eliminar.
$eliminarElemento = array(0 => 'elem_1', 1 => 'elem_2', 2 => 'elem_3', 3 => 'elem_4'); // Muestro elementos de Array foreach($eliminarElemento as $elmClave => $elmValor){ echo "Índice: " . $elmClave . " ==> " . $elmValor . "<br />"; } echo "Elimino el elemento con índice 1 y vuelvo a mostrar el array."; // Elimino elemento Array unset($eliminarElemento[1]); // Vuelvo a mostrar los elementos de Array foreach($eliminarElemento as $elmClave => $elmValor){ echo "Índice: " . $elmClave . " ==> " . $elmValor . "<br />"; }Índice: 0 ==> elem_1
Elimino el elemento con índice 1 y vuelvo a mostrar el array.
Índice: 0 ==> elem_1Para cambiar el valor de un elemento de un Array solo tenemos que colocar una sentencia if, indicando que si la variable del valor, en cualquier vuelta es "nombreValor" indicamos el nombre del valor a cambiar, entonces dentro de la instrucción de if le decimos que esa variable en esta vuelta ahora su valor cambia a otro "cambioNombreValor".
$cambioColor = array('rojo', 'amarillo', 'verde', 'azul', 'violeta');
$contador = 0;
foreach($cambioColor as $valColor){
$contador++; // Suma 1 en cada iteración
// Si el valor es 'verde' ...
if($valColor == 'verde'):
$valColor = 'marrón'; // cambiamos el color por 'marrón'
endif;
// Mostrar elementos de Array
echo "Color " . $contador . " ==> " . $valColor . "<br /> ";
} array_flip: mediante esta función cambiamos la clave de un array por su valor y viceversa
$girarPing = array ('valor_0', 'valor_1', 'valor_2');
var_dump($girarPing); // Resultado
echo "Cambiar la clave por su valor y el valor por la clave.";
var_dump(array_flip($girarPing)); // Cambiar claves por valores 0/ valor_0 Cambiar la clave por su valor y el valor por la clave:
valor_0/ 0array_reverse: Para poder invertir el orden de los valores de un Array utilizaremos esta función.
$inventores = array('submarino' => 'Narciso Monturiol',
'autogiro' => 'Juan de la Cierva',
'chupa chups' => 'Enric Bernat',
'fregona' => 'Manuel Jalón',
'cigarrillo' => 'Mendigos sevillanos',
'bota de vino' => 'Navarros');
// Array ordenado
foreach($inventores as $claInventor => $valInventor){
echo $claInventor . " --> " . $valInventor . "<br />";
}
// Invertir el orden de los elementos del Array:
print_r(array_reverse($inventores)); submarino --> Narciso Monturiol
autogiro --> Juan de la Cierva
chupa chups --> Enric Bernat
fregona --> Manuel Jalón
cigarrillo --> Mendigos sevillanos
bota de vino --> Navarros
Invertir el orden de los elementos del Array:
bota de vino ->Navarros
cigarrillo ->Mendigos sevillanos
fregona ->Manuel Jalón
chupa chups ->Enric Bernat
autogiro ->Juan de la Cierva
submarino ->Narciso Monturiol
sort(): Esta función ordena los valores alfabéticamente en el caso de cadena de carácteres y numéricamente en el caso de valores numéricos y de menor a mayor.
$ordenarArray = array('Españoles', 'Italianos', 'Argentinos',
'Canadienses', 'Franceses', 'Rusos');
// Array sin ordenar:
foreach($ordenarArray as $desordArray){
echo $desordArray . "<br />";
}
// Array ordenado:
sort($ordenarArray);
foreach($ordenarArray as $ordArray){
echo $ordArray . "<br />";
}Array al inicirse:
EspañolesArray ordenado sort():
Argentinosrsort() : Ordena los valores de mayor a menor, es decir, en orden inverso y sin mantener la relación entre indice y valor, es decir que al ser ordenado el valor su índice será uno nuevo segun su orden.
$ordenarArray2 = array('3' => 'Españoles', '5' => 'Italianos',
'2' => 'Argentinos', '4' => 'Canadienses',
'1' => 'Franceses', '0' => 'Rusos');
// Ordenar de mayor a menor
rsort($ordenarArray2);
// Recorrer el array
foreach($ordenarArray2 as $clarsort => $valrsort){
echo $clarsort . "/ " . $valrsort . "<br />";
}0/ Rusos Ordenar de menor a mayor, manteniendo índice de cada valor
asort() : Ordena de menor a mayor, pero respetando le relación de clave con valor, el resultado final es el ordenamiento de los valores, no de los índices, es decir que al ser ordenado el valor su índice se mantendrá indiferentemente del número de orden que tenga.
$ordarrasort = array('3' => 'Españoles', '5' => 'Italianos',
'2' => 'Argentinos', '4' => 'Canadienses',
'1' => 'Franceses', '0' => 'Rusos');
// Ordenar de menor a mayor con relación (clave / valor)
asort($ordarrasort);
// Recorrer el array
foreach($ordarrasort as $claasort => $valasort){
echo $claasort . "/ " . $valasort . "<br />";
}2/ Argentinos Ordenar elementos de mayor a menor, manteniendo índice de cada valor
arsort(): Ordena un array en orden inverso y mantiene la asociación de valores y sus índices. Es utilizado principalmente cuando se ordenan arrays asociativos cuando el orden de los elementos es importante.
$ordarrarsort = array('3' => 'Españoles', '5' => 'Italianos',
'2' => 'Argentinos', '4' => 'Canadienses',
'1' => 'Franceses', '0' => 'Rusos');
// Ordenar de mayor a menor con relación (clave / valor)
arsort($ordarrarsort);
// Recorrer el array
foreach($ordarrarsort as $claarsort => $valarsort){
echo $claarsort . "/ " . $valarsort . "<br />";
}0/ Rusos Ordenar alfanuméricamente las claves de menor a mayor, manteniendo asociación clave con valor
ksort(): Ordena un array de menor a mayor por su clave, manteniendo la correlación entre la clave y valores. Esto es útil principalmente para arrays asociativos.
$ordarrksort = array('3' => 'Españoles', '5' => 'Italianos',
'2' => 'Argentinos', '4' => 'Canadienses',
'1' => 'Franceses', '0' => 'Rusos');
// Ordenar de menor a mayor con relación (clave / valor)
ksort($ordarrksort);
// Recorrer el array
foreach($ordarrksort as $claksort => $valksort){
echo $claksort . "/ " . $valksort . "<br />";
}0/ RusosOrdenar alfanuméricamente las claves de mayor a menor, manteniendo asociación clave con valor
krsort(): Ordena un array de mayor a menor por su clave, manteniendo la correlación entre la clave y valores. Esto es útil principalmente para arrays asociativos.
$ordarrkrsort = array('3' => 'Españoles', '5' => 'Italianos',
'2' => 'Argentinos', '4' => 'Canadienses',
'1' => 'Franceses', '0' => 'Rusos');
// Ordenar de mayor a menor con relación (clave / valor)
krsort($ordarrkrsort);
// Recorrer el array
foreach($ordarrkrsort as $clakrsort => $valkrsort){
echo $clakrsort . "/ " . $valkrsort . "<br />";
}0/ Rusosusort(): Ordena elementos de una matriz comparando sus valores mediante una función de comparación definida por el usuario, función que se pasa como segundo argumento. Si dos valores se comparan como iguales, su orden relativo en el array ordenado es indefinido.
function funusort($Ausort, $Busort){
// ORDENACIÓN DE ELEMENTOS
// Si igualdad en valores, devuelve 'false'
if ($Ausort == $Busort) return 0;
// Ordenamos de mayor a menor.
// Si A mayor que B, colocamos A delante,
// sino, colocamos B delante de A.
return ($Ausort > $Busort) ? -1 : 1;
}
$arrusort = array('1' => 'Españoles', '2' => 'Británicos', '3' => 'Griegos',
'4' => 'Noruegos', '5' => 'Españoles');
// Matriz y función que decide como ordenar los elementos
usort($arrusort, 'funusort');
// Mientras que variables asignadas sean iguales
// a elementos recorridos por 'each' del array
// mostraremos los elementos.
// 'list()' Asigna variables como si fuera un array
while (list($clausort, $valusort) = each($arrusort) ){
echo $clausort . "/ " . $valusort . "<br />";
}0 => Noruegos uksort(): Ordena las claves de una matriz comparando sus índices mediante una función de comparación definida por el usuario, función que se pasa como segundo argumento, pero respetando la asociación entre clave y valor.
function funuksort($Auksort, $Buksort){
// ORDENACIÓN DE CLAVES
// Si igualdad en valores, devuelve 'false'
if ($Auksort == $Buksort) return 0;
// Ordenamos de mayor a menor.
// Si A mayor que B, colocamos A delante,
// sino, colocamos B delante de A.
return ($Auksort > $Buksort) ? -1 : 1;
}
$arruksort = array('1' => 'Españoles', '2' => 'Británicos', '3' => 'Griegos',
'4' => 'Noruegos', '5' => 'Españoles');
// Matriz y función que decide como ordenar los elementos
uksort($arruksort, 'funuksort');
// Mientras que variables asignadas sean iguales
// a elementos recorridos por 'each' del array
// mostraremos los elementos.
// 'list()' Asigna variables como si fuera un array
while (list($clauksort, $valuksort) = each($arruksort) ){
echo $clauksort . "/ " . $valuksort . "<br />";
}5 => Españoles // Función que compara dos variables function cmp($a, $b){ // La (@) arroba omite el mensaje "WARNING" de error en caso de no encontrar algún elemento que no contenga los carácteres a reemplazar. $a = preg_replace('@^(un|una|la) @', '', $a); // Si clave contiene al principio (^) las cadenas (un o una o la), las cambia por ("") cadena vacia $b = preg_replace('@^(un|una|la) @', '', $b); // Si clave contiene al principio (^) las cadenas (un o una o la), las cambia por ("") cadena vacia return strcasecmp($a, $b); } $arruk = array("Víctor" => 1, "la Tierra" => 2, "una manzana" => 3, "un plátano" => 4); ; // Llamada a función para comparar valores de Array "$arruk" uksort($arruk, "cmp"); foreach ($arruk as $clave => $valor) { echo $clave . ": " . $valor . "/n"; }una manzana: 3
uasort(): Ordena las claves de una matriz comparando sus índices mediante una función de comparación definida por el usuario, función que se pasa como segundo argumento, pero respetando la asociación entre clave y valor.
function funuasort($Auasort, $Buasort){
// ORDENACIÓN DE CLAVES
// Si igualdad en valores, devuelve 'false'
if ($Auasort == $Buasort) return 0;
// Ordenamos de menor a mayor.
// Si A menor que B, colocamos A delante,
// sino, colocamos B delante de A.
return ($Auasort < $Buasort) ? -1 : 1;
}
$arruasort = array('Españoles' => '1', 'Británicos' => '2', 'Griegos' => '3',
'Noruegos' => '4', 'Españolas' => '5');
// Matriz y función que decide como ordenar los elementos
uasort($arruasort, 'funuasort');
// Mientras que variables asignadas sean iguales
// a elementos recorridos por 'each' del array
// mostraremos los valores.
// 'list()' Asigna variables como si fuera un array
while (list($clauasort, $valuasort) = each($arruasort) ){
echo $clauasort . "/ " . $valuasort . "<br />";
}Británicos => 2 array_multisort(): Útil para ordenar varios arrays al mismo tiempo, o para ordenar arrays multidimensionales.
El comportamiento para la ordenación con la función array_multisort() es que los índices coincidentes de los dos arrays antes de la ordenación, seguirán manteniendo la misma coincidencia después de la ordenación. Es decir que si el 3er índice del primer array es ordenado en la primera posición del array, el segundo array colocará el 3er índice también en la primera posición del array, y así hará con el resto de sus elementos.
// Ordenar Array de dimension 2 $ocupacionmulti = array ( array( 'Vicente Carcasona', '43', 'Empresario', '28000' ), array( 'Estevan Garcia', '48', 'Comercial', '35000' ), array( 'Anna Maria', '44', 'Policia', '120000' ) ); // Recorremos los 3 arrays foreach ($ocupacionmulti as $valocup){ // Recorremos los elementos de cada array foreach ($valocup as $valocup2){ echo $valocup2 . " - "; } echo '<br />'; } // Ordenación de array dimensión 2 array_multisort($ocupacionmulti);Vicente Carcasona - 43 - Empresario - 28000 -
// Ordenar 2 Arrays $multiArray1 = array('aa', 'ee', '44', 'gg', 'cc'); $multiArray2 = array('dd ', 'bb', 'hh', '77', 'ff'); // Ordenar de forma ascendente los arrays, (útil para ordenar arrays con nombres/contraseñas). // Al ordenar el primer Array mueve los valores, de forma que el segundo Array hace que sus // valores se muevan en la posición coincidiendo con el mismo índice que antes de la ordenación. array_multisort($multiArray1, SORT_ASC $multiArray2); echo 'Array 1'; foreach($multiArray1 as $clamultiArray1 => $valmultiArray1){ echo $valmultiArray1 . " - "; } echo "<br />Array 2:"; foreach($multiArray2 as $clamultiArray2 => $valmultiArray2){ echo $valmultiArray2 . " - "; }Array 1:44 - aa - cc - ee - gg
natcasesort(): ordenación natural. Ordena una matriz sin tener en cuenta la diferencia entre minúsculas y mayúsculas y manteniendo el orden natural. Esto significa mantener la relación clave/valor.
$natcasearray = array('4' => 'puerto_serie', '1' => 'puerto_VGA',
'2' => 'puerto_Usb',
'3' => 'puerto_red_LAN');
// Ordenación natural (relación clave/valor), insensible a mayúsculas/minúsculas
natcasesort($natcasearray);
foreach($natcasearray as $clanatcasearray => $valnatcasearray){
echo $clanatcasearray . "/ " . $valnatcasearray . " - ";
}
Ordenación con sort(), sensible a mayúsculas/minúsculas
0/ puerto_Usb - 1/ puerto_VGA - 2/ puerto_red_LAN - 3/ puerto_serieDesordenar el Array con shuffle()
0/ puerto_serie - 1/ puerto_red_LAN - 2/ puerto_Usb - 3/ puerto_VGAVolver a ordenar con natcasesort(), insensible a mayúsculas/minúsculas
1/ puerto_red_LAN - 0/ puerto_serie - 2/ puerto_Usb3/ puerto_VGA -Ordenar matriz manteniendo el orden natural (asociar calve/valor)
natsort(): La matriz ordena la cadena alfanuméricamente manteniendo el orden natural (asocia clave/valor).
$natarray = array('4' => 'port_1', '1' => 'port_10',
'2' => 'port_2', '3' => 'port_25', '0' => 'port_0');
// Ordenar Array alfanuméricamente
natsort($natarray);
foreach($natarray as $clanatsort => $valnatsort){
echo $clanatsort . " - " . $valnatsort;
}Ordenar con natsort():
0 - port_04 - port_12 - port_21 - port_103 - port_25Ordenar con sort():
0 - port_01 - port_12 - port_103 - port_24 - port_25shuffle(): Esta función mezcla los elementos de un array de forma aleatoria. Redondea aleatoriamente una matriz, devolviendo la misma matriz desordenada. Esta función se considera destructiva.
// Desordenar aleatoriamente un Array: $desordenarArray = array('Españoles', 'Italianos', 'Argentinos', 'Canadienses', 'Franceses', 'Rusos'); // Desordenar Array shuffle($desordenarArray); foreach($desordenarArray as $resltdArray){ echo $resltdArray . "<br />"; }
Desordenar elementos de un Array:
Españoles// Desordenar un rango de números entre el 1 y el 10 $numshu = range(1, 10); // Desordenamos rango shuffle($numshu); foreach($numshu as $rangnum => $valrangnum){ echo $valrangnum . " - "; }
Desordenar un rango de números del 1 al 10:
1 - 3 - 5 - 10 - 9 - 8 - 7 - 4 - 6 - 2Trabajar con un conjunto de Arrays nos garantiza la suma, resta o intersección de estos.
La suma de los conjuntos es la unión de estos mediante el operador suma (+).
La resta o diferencia del primer conjunto menos el segundo y se realiza con la función array_diff().
La intersección de dos conjuntos la realizamos con array_intersect() y devuelve todos los elementos que tienen algo en común (idénticos).
$conA = array('a', 'bre', 'la');
$conB = array('a', 'bre', 'la', 'tas');
// Unión (elementos que tienen algo en común no los repite):
$unir = $conA + $conB;
foreach($unir as $valUnir){
echo $valUnir;
}
// Diferencia (elementos que no tienen nada en común):
$diferencia = array_diff($conB, $conA);
foreach($diferencia as $valdiferencia){
echo $valdiferencia;
}
// Intersección (elementos que se tienen en común):
$interseccion = array_intersect($conB, $conA);
foreach($interseccion as $valinterseccion){
echo $valinterseccion;
} Unión (elementos que tienen algo en común no los repite):
abrelatasDiferencia (elementos que no tienen nada en común):
tasIntersección (elementos que se tienen en común):
abrelaarray_rand: Esta función busca una clave al azar de un elemento, de un determinado Array y la devuelve.
Para obtener el valor de esa clave tenemos que colocar la función entre corchetes "[array_rand($nombreArray)]"
$inventores = array('submarino' => 'Narciso Monturiol',
'autogiro' => 'Juan de la Cierva',
'chupa chups' => 'Enric Bernat',
'fregona' => 'Manuel Jalón');
// Buscar clave aleatoria
echo "<p>Este es el valor aleatorio: " . array_rand($inventores)
. "</p>";
// Buscar valor aleatorio
echo "<p>Esta es la clave aleatoria: "
. $inventores[array_rand($inventores)]
. "</p>";
Esta es la clave aleatoria: submarino
Este es el valor aleatorio: Narciso Monturiol