Arrays

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.

Arrays escalares

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

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>"; 
Índices012
Valores Alemania Austria Bélgica

Operadores de Array

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

Array bidimensional Asociativo

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
AlemaniaBerlín55705678420000
AustriaViena838497614000
BélgicaBruselas305189932000

Comparación de Arrays con operadores

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 (!=)

Contar elementos de un Array

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.

Método count() y sizeof()

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

Arrays multidimensionales

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

Array de dimensión 2

$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 multidimensionales asociativos

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 multidimensionales con "for"

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

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 - 35000
Gines Giménez - 45 - Sastre, confeccionista - 22000
Carla Pons - 37 - Comercial, oficinista - 28500

Iterar con "for"/"foreach" (asociativos)

No 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 -
Gines Giménez - 45 - Sastre, confeccionista - 22000 -
Carla Pons - 37 - Comercial, oficinista - 28500 -

Iterar Array tridimensional

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>";

Array mixto (índices escalares y asociativos)

// Í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 2COLUMNAS 3 y 4COLUMNAS 5 y 6
Colum 00.10.20.30.40.5
1.0Colum 11.21.31.41.5
2.02.1Colum 22.32.42.5
3.03.13.2Colum 33.43.5
4.04.14.24.3Colum 44.5
5.05.15.25.35.4Colum 5
Datos de Array en tabla
COLUMNAS 1 y 2COLUMNAS 3 y 4COLUMNAS 5 y 6
00.10.20.30.4Fila 0
11.11.21.31.4Fila 1
22.12.22.35.4Fila 2
33.13.23.33.4Fila 3
44.14.24.34.4Fila 4
55.15.25.35.4Fila 5

Funciones para imprimir matrices

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); 

Reducir tamaño de un Array

"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
2/ discoduro
// 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
2/ microprocesador
3/ discoduro
4/ ram ddr2
// 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
2/ ventilador
3/ microprocesador
Subir

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

Subir

array_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 ddr2

Elemento extraido => ram ddr2

Ahora el Array tiene => 5 elementos

gráficadisqueteraventiladormicroprocesadordiscoduro

Subir

Aumentar el tamaño de una matriz

array_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:

  1. gráfica
  2. disquetera
  3. ventilador
  4. microprocesador
  5. discoduro
  6. ram ddr2

Vector aumentado:
  1. gráfica
  2. disquetera
  3. ventilador
  4. microprocesador
  5. discoduro
  6. ram ddr2
  7. bios
  8. chipset
Subir

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  
Subir

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
uno __ Italia

dos __ Francia
dos __ Francia

tres -- España

0 -- UK

1 -- Brasil

2 -- Canadá

3 -- Portugal

4 -- Argentina

// 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>";
Subir

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áfica
2/ disquetera
3/ ventilador
4/ microprocesador
5/ discoduro
6/ ram ddr2

Elementos del nuevo Array:

1/ bios
2/ chipset
3/ gráfica
4/ disquetera
5/ ventilador
6/ microprocesador
7/ discoduro
8/ ram ddr2

Subir

array_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ÓN

Array 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ÓN

Array 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 Array

Subir

Intersección de matrices (elementos comunes)

array_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  
Subir

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

Subir

array_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
jueves 3
Subir

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
2/ 3
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 = DO
notas 1 =Campo duplicado
notas 2 =Campo duplicado
notas 3 = RE
notas 4 =Campo duplicado
notas 5 =Campo duplicado
notas 6 = MI
notas 7 =Campo duplicado

Número de elementos en Array notas =3

Subir

Creación de matrices, compact()

compact(): 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.

Apellidos -> Granados Sánchez
Nombre -> Samuel
Edad -> 37

Creación de variables, extract()

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.

Proceso secuencial de toda la matriz

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()

Color
Altura
Ancho
Peso

Valores en orden inverso con prev():

105
1.15
2 metros
Azul

Navegación con each(): devuelve valor y clave

Color : Azul
Altura : 2 metros
Ancho : 1.15
Peso : 105

array_walk(), 'caminar'

Esta 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"
La clave 2/ tiene el valor "Flash"

------------------------------------------------------
// 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


Busqueda de un elemento de la matriz

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:

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 Alberto
6 Anna

array_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: 0
La clave de Gerard es:
La clave de Pedro es: 5

in_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 valor

array_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 Array

Agregar elementos a un Array

Una 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

Eliminar elemento de un Array

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
Índice: 1 ==> elem_2
Índice: 2 ==> elem_3
Índice: 3 ==> elem_4

Elimino el elemento con índice 1 y vuelvo a mostrar el array.

Índice: 0 ==> elem_1
Índice: 2 ==> elem_3
Índice: 3 ==> elem_4

Cambiar un elemento de un Array

Para 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 /> ";
		
	} 

Flipping

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
1/ valor_1
2/ valor_2

Cambiar la clave por su valor y el valor por la clave:

valor_0/ 0
valor_1/ 1
valor_2/ 2

Invertir orden de elementos de Array

array_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

Ordenar elementos alfabéticamente

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ñoles
Italianos
Argentinos
Canadienses
Franceses
Rusos

Array ordenado sort():

Argentinos
Canadienses
Españoles
Franceses
Italianos
Rusos

Ordenar elementos de mayor a menor

rsort() : 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
1/ Italianos
2/ Franceses
3/ Españoles
4/ Canadienses
5/ Argentinos

Ordenar de menor a mayor

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
4/ Canadienses
Es/ Españoles
1/ Franceses
It/ Italianos
0/ Rusos

Ordenar elementos de mayor a menor

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
It/ Italianos
1/ Franceses
Es/ Españoles
4/ Canadienses
2/ Argentinos

Ordenar alfanuméricamente claves(menor a mayor)

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/ Rusos
Es/ Españoles
It/ Italianos
1/ Franceses
2/ Argentinos
4/ Canadienses

Ordenar alfanuméricamente claves (mayor a menor)

Ordenar 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/ Rusos
Es/ Españoles
It/ Italianos
1/ Franceses
2/ Argentinos
4/ Canadienses

Ordena valores mediante (función usuario)

usort(): 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
1 => Griegos
2 => Españoles
3 => Españoles
4 => Británicos

Ordena índices mediante (función usuario)

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
4 => Noruegos
3 => Griegos
2 => Británicos
1 => 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
un plátano: 4
la Tierra: 2
Víctor: 1

Ordena índices mediante (función usuario)

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
Españolas => 5
Españoles => 1
Griegos => 3
Noruegos => 4

Ordena varias matrices en un solo paso

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 -
Estevan Garcia - 48 - Comercial - 35000 -
Anna Maria - 44 - Policia - 120000 -
// 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
Array 2:hh - dd - ff - bb - 77

Ordenar matriz, insensible a mayúsculas-minúsculas

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_serie

Desordenar el Array con shuffle()

0/ puerto_serie - 1/ puerto_VGA - 2/ puerto_red_LAN - 3/ puerto_Usb

Volver a ordenar con natcasesort(), insensible a mayúsculas/minúsculas

2/ puerto_red_LAN0/ puerto_serie - 3/ puerto_Usb - 1/ puerto_VGA -

Ordenar matriz manteniendo orden natural

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_25

Ordenar con sort():

0 - port_01 - port_12 - port_103 - port_24 - port_25

Desordenar elementos de una matriz

shuffle(): 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:

Italianos
Franceses
Argentinos
Españoles
Canadienses
Rusos
// 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:

7 - 6 - 4 - 5 - 2 - 1 - 9 - 10 - 8 - 3

Arrays como conjuntos

Trabajar 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):

abrelatas

Diferencia (elementos que no tienen nada en común):

tas

Intersección (elementos que se tienen en común):

abrela

Obtener elemento al azar de Array

array_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: Juan de la Cierva

Volver