Home | Clases | Programación en PHP | Arrays

Arrays


Los arrays son, sin duda, la estructura de datos más potente de PHP, así como de muchos otros lenguajes.

Se flexibilidad les permite almacenar cualquier tipo de valor, incluyendo otros arrays, y es por ello que PHP tiene más de 70 funciones diseñadas exclusivamente para manipular arrays y que se pueden consultar en la página oficial de PHP.

Introducción

Un array es una colección ordenada de ítems o elementos. Cada elemento posee un valor o value y es identificado dentro del array por un índice único o key, que puede ser de tipo int o de tipo string.

Podemos crear arrays indistintamente utilizando el constructor array() o bien mediante el operador array []. A continuación se muestran ejemplos de las dos maneras:

<?php
$a = array (10, 20, 30);
$a = array (’a’ => 10, ’b’ => 20, ’cee’ => 30);
$a = array (5 => 1, 3 => 2, 1 => 3,);
$a = array();

$x[] = 10;
$x[’aa’] = 11;
?>


Es importante remarcar que, si no indicamos el índice o key, PHP asignará automáticamente uno numérico, empezando por 0.

Una vez inicializado el array, es posible acceder a él o incluso imprimirlo entero de diferentes maneras:

<?php
$a = array (’a’ => 10, ’b’ => 20, ’cee’ => 30);
echo $a['a']; //Devolverá 10
print_r($a); //Imprimirá el array como un string
var_dump($a); //Devolverá el array, incluyendo el tipo de variable pero interrumpiendo el resto del script
?>


Los arrays se pueden dividir en dos grandes grupos, los enumerativos y los asociativos:

  • arrays enumerativos: aquellos que son indexados solo utilizando valores numéricos
  • arrays asociativos: aquellos que son indexados con cualquier tipo de indice, sea numérico o string.

En PHP, los índices o keys de los arrays no tiene por qué ser consecutivos - ni siquiera positivos, incluso admite valores negativos -, de modo que podemos tener espacios en el indexado del array sin que eso suponga mayor problema. Así, por ejemplo, si se añade un elemento a un array sin especificar su key, automáticamente se le aplica el último índice numérico del array + 1, incluso en el caso de los asociativos:

<?php
$a = array (2 => 5);
$a[] = 'a'; //El índice será 3
$b = array (’4’ => 5, ’a’ => ’b’);
$b[] = 44; // El índice será 5
?>

Además, ya que dijimos que los arrays pueden contener cualquier tipo de valor, incluso otros arrays, también es posible utilizar arrays multidimensionales:

<?php
$array = array();
$array[] = array( ’Juan’, ’Pedro’ );
$array[] = array( ’Madrid’, ’Toledo’ );
echo $array[0][1] . " es de " . $array[1][0]; // Devolverá Pedro es de Madrid
?>

Por último, para cuando trabajemos con bases de datos y como ya vimos en el apartado de funciones, es posible asignar valores de un array a variables individuales mediante el uso del constructor list():

<?php
$sql = "SELECT usuario, nombre, email FROM usuarios";
$result = mysql_query($sql);
while (list($usuario, $nombre, $email) = mysql_fetch_row($result)) {
echo "El usuario: " . $usuario . " se llama: " . $nombre . " y su email es: " . $email . ".<br>";
}
?>


Operaciones con arrays

Es posible utilizar operadores con arrays, tal y como vimos anteriormente con otros tipos de variables, si bien en este caso, los resultados no son tan evidentes.

Por ejemplo, utilizando el operador suma + podemos combinar dos o más arrays, con las siguientes consideraciones:

<?php
$a = array (1, 2, 3);
$b = array (’a’ => 1, ’b’ => 2, ’c’ => 3);
var_dump ($a + $b);

/*El resultado será:
array(6) { [0]=> int(1)
[1]=> int(2)
[2]=> int(3)
["a"]=> int(1)
["b"]=> int(2)
["c"]=>int(3)
}
*/
?>

Es decir, el array resultante incluirá todos los elementos de los dos arrays originales, aunque tengan los mismo valores. Sin embargo, si los dos arrays comparten índices y valores, solo aparecerán una vez en el array resultado, tal y como muestra el siguiente ejemplo:

<?php
$a = array (1, 2, 3);
$b = array (’a’ => 1, 2, 3);
var_dump ($a + $b);

/*El resultado será:
array(4) { [0]=> int(1)
[1]=> int(2)
[2]=> int(3)
["a"]=> int(1)
}*/
?>


Otra operación, aunque poco frecuente, es la de comparar arrays. Dos arrays se considerarán iguales (operador ==) siempre que tengan el mismo número de elementos con los mismos valores e índices, independientemente del orden. Se considerarán idénticos (operador ===) solo si además están en el mismo orden.

<?php
$a = array (1, 2, 3);
$b = array (1 => 2, 2 => 3, 0 => 1);
$c = array (’a’ => 1, ’b’ => 2, ’c’ => 3);

var_dump ($a == $b); // True
var_dump ($a === $b); // False
var_dump ($a == $c); // True
var_dump ($a === $c); // False

var_dump ($a != $b); // False
var_dump ($a !== $b); // True
?>


El tamaño de un array se puede recoger con la función count(), mientras que para comprobar si existe un elemento con un un determinado índice dentro del array, debemos utilizar la función array_key_exists() y para comprobar si existe un elemento con un un determinado valor utilizaremos in_array(). Por último, para eliminar un elemento concreto de un array, utilizaremos la función unset():

<?php
$a = array (1, 2, 3);
count($a); //Devolverá 3

echo array_key_exists ($a[1]); // True
echo array_key_exists ($a[3]); // False

echo in_array ($a, 2); // True
echo in_array ($a, 0); // False

unset ($a, 1); // True
echo in_array ($a, 1); // False
?>


Iteraciones con arrays

Cuando utilicemos arrays para almacenar cualquier tipo de datos, sin duda lo que más nos va a interesar es saber cómo podemos recorrer y acceder a esos datos.

La forma más común de hacerlo será mediante un bucle foreach, recorriendo solo los valores o los indices y los valores, según nuestras necesidades:

<?php
$a = array ('texto1', 'texto2', 'texto3');

foreach ($a as $valor){
echo $valor;
}
//Devolverá texto1texto2texto3

foreach ($a as $indice => $valor){
echo $indice . ": " .$valor. " / ";
}
//Devolverá 0: texto1 / 1: texto2 / 2: texto3 /
?>


Ordenando arrays

Existen 11 funciones de PHP cuyo objetivo es la ordenación de arrays.

La más simple de todas ellas es sort(), que ordena en función de los valores. Es válida para arrays unidimensionales en los que los índices no son importantes, ya que, como muestra el siguiente ejemplo, esta función destruye los índices originales asignando unos nuevos de forma numérica:

<?php
$a = array ('a' => 'textoc', 'b' => 'textoa', 'c' => 'textob');

sort($a);
var_dump($a);

/*El resultado será:
array(3) {
[0] => string(6) "textoa"
[1]=> string(6) "textob"
[2]=> string(6) "textoc"
}*/
?>

Si lo que queremos es ordenar en función de los valores pero conservando los índices originales, debemos utilizar la función asort():

<?php
$a = array ('a' => 'textoc', 'b' => 'textoa', 'c' => 'textob');

asort($a);
var_dump($a);

/*El resultado será:
array(3) {
['b'] => string(6) "textoa"
['c']=> string(6) "textob"
['a']=> string(6) "textoc"
}*/
?>


En ambos casos, la ordenación es ascendente. Para hacer la ordenación descendente debemos utilizar, respectivamente, las funciones rsort() y arsort(). Además, podemos añadir un segundo argumento a la función para indicar el tipo de comparación que más nos convenga a la hora de realizar la ordenación:

  • SORT_REGULAR: Comparación tal cual, sin ninguna conversión de los datos. Es la que usa por defecto.
  • SORT_NUMERIC: Cada elemento es convertido a un valor numérico antes de la comparación.
  • SORT_STRING: Compara todos los elementos como cadenas o strings.

Puesto que la ordenación en estos casos se hace de forma numérica o byte a byte en el caso de los strings, en ocasiones puede resultar poco natural, ya que, por ejemplo, '10t' será considerado menor que '2t' al empezar por un 1. Para solucionar esto, se puede usar natsort(), que además mantiene, al igual que asort(), los índices originales. Si además queremos hacer la ordenación insensible a mayúsculas y minúsculas, debemos usar natcasesort().

Además de las funciones comentadas y de manera análoga a asort() y arsort(), es posible la ordenación en función de los índices o keys, utilizando en este caso las funciones ksort() y krsort(), respectivamente.

También es posible realizar la ordenación de un array a partir de una función definida por el usuario mediante el uso de las funciones:

  • usort(): por valores sin respetar índices
  • uasort(): por valores respetando índices
  • uksort(): por índices


En este caso, primero tendremos que declarar la función de comparación y luego aplicar la función de ordenación correspondiente:

<?php
$a = array ('tres', '2dos', 'uno', 'dos');

function comparar($izquierda,$derecha){
//Ordena en función de la longitud del valor
$diferencia = strlen($izquierda) - strlen($derecha);
if (!$diferencia) { //si tienen la misma longitud
return strcmp ($izquierda, $derecha); //Devuelvo la comparación de los dos strings a nivel binario
}
return $diferencia; //Devuelvo la diferencia en caracteres de los dos strings
}

usort($a, 'comparar');
var_dump($a);

/*El resultado será:
array(4) {
[0] => string(6) "dos"
[1]=> string(6) "uno"
[2]=> string(6) "2dos"
[3]=> string(6) "tres"
}*/
?>

Al igual que existen funciones de ordenación, existe una función que nos permite desordenar un array de manera aleatoria sin respetar los índices con la función shuffle(). No obstante es posible mantener los índices originales si previamente los extraemos con la función array_keys(), una función que devuelve un array cuyos valores son los índices del array de entrada. El uso de estas funciones se muestra en el siguiente ejemplo:

<?php
$a = array ('a' => 10, 'b' => 12, 'c' => 13);
$keys = array_keys($a);

shuffle($a);
var_dump($a); //Devolverá un array con los índices y valores mezclados de forma aleatoria

foreach ($keys as $key) {
echo $key . " - " . $a[$key]; //Devolverá una lista con valores mezclados de forma aleatoria y sus índices originales
}
?>


Si sólo necesitáramos extraer uno o más elementos aleatorios de un array, podemos usar la función array_rand($array, num), donde num es el número de elementos que queremos extraer. El resultado será un array con los elementos extraídos.

Y para terminar, es posible ordenar un array asociativo multidimensional mediante la función array_multisort(), si bien esto requiere de un array intermedio en el que extraigamos la "columna" de ordenación. El uso de esta función queda detallado en el siguiente ejemplo:


<?php
//Array de Personas
$personas = [
[
'nombre' => 'Jairo',
'apellido' => 'García',
'edad' => 43
],
[
'nombre' => 'Juan',
'apellido' => 'Palomo',
'edad' => 22
],
[
'nombre' => 'Luís',
'apellido' => 'Andrade',
'edad' => 54
],
[
'nombre' => 'Alberto',
'apellido' => 'Pérez',
'edad' => 18
],
[
'nombre' => 'Miguel',
'apellido' => 'Yuste',
'edad' => 36
]
];

//Ordena array de personas por nombre ascendente
foreach ($personas as $key => $row){
$nombres[$key] = $row['nombre']; //Obtengo array de nombres con los índices originales
}
array_multisort($nombres, SORT_ASC, $personas);

//Ordena array de personas por apellido ascendente
foreach ($personas as $key => $row){
$apellidos[$key] = $row['apellido']; //Obtengo array de apellidos con los índices originales
}
array_multisort($apellidos, SORT_ASC, $personas);

//Ordena array de personas por edad descendente
foreach ($personas as $key => $row){
$edades[$key] = $row['edad']; //Obtengo array de edades con los índices originales
}
array_multisort($edades, SORT_DESC, $personas);
?>


NOTA: Si queremos usar una función externa para la ordenación que no devuelve nada pero modifica el array de entrada (por ejemplo $array), debemos pasar a la función dicho array como parámetro por referencia mediante &$array.

Los arrays como stacks o queues

Frecuentemente utilizaremos los arrays como stacks (estructuras LIFO) o queues (estructuras FIFO). Para estos casos, PHP proporciona una serie de funciones que nos pueden facilitar la tarea.

<?php
//Arrays como stacks LIFO
$stack = array();
array_push($stack, 'uno', 'dos'); //añade dos elementos al array
$ultimo_en_entrar = array_pop($stack); //añade dos elementos al array
echo $ultimo_en_entrar; //devuelve dos

//Arrays como queues FIFO
$queues = array(’uno’, ’dos’, ’tres’);
$primer_elemento = array_shift($queues); //extrae el primer elemento del array
echo $primer_elemento; //devuelve uno
array_unshift($queues, ’cuatro’); //añade cuatro al principio del array
echo $queues[0];; //devuelve cuatro
?>


Ejercicios propuestos:

  • Desarrolla un array multidimensional que incluya todos los días del año de modo que se pueda acceder a cada elemento en la forma $array[6][15] y un echo devuelva "15 de Junio".
  • Crea una función que muestre en pantalla una tabla con el contenido del array superglobal de PHP $_SERVER, incluyendo el significado de cada índice.
  • Crea una función que, dado un array de enteros de 0 a 100, extraiga 3 elementos al azar y devuelva la media de ellos en formato "La media de num1, num2 y num3 es resultado".
  • Crea un array asociativo con los nombres y números de los meses del año e imprímelo. A continuación, ordénalo de forma ascendente respetando los índices según el tamaño del texto.
  • Modifica el ejemplo anterior para que el orden sea descendente.
  • Crea un array asociativo de al menos 10 productos con nombre, precio y tipo de iva (1, 2, 3 ó 4). Crea un array de ivas con los tipos de iva como índices y el porcentaje de iva como valores (0%, 4%, 10% y 21%). Recorre el array de productos y muestra en pantalla el listado de productos, su precio sin iva, el tipo de iva y su precio con iva.
  • Modifica el ejercicio anterior para que muestre los productos ordenados por nombre.
  • Modifica el ejercicio anterior para que muestre los productos ordenados por su precio con iva.



Fecha de publicación: 06/09/2019
Asignaturas: desarrollo web en entorno servidor
Temas: php variables bucles arrays
Utilizamos cookies propias y de terceros para mejorar su experiencia en la navegación. Al seguir navegando entendemos que acepta su uso.
Si lo desea, consulte nuestras políticas de privacidad y cookies
ENTENDIDO
[X] Cerrar

Contacta conmigo


[X] Cerrar

Acceso alumnos