Un array en PHP es en realidad un mapa ordenado. Un mapa es un tipo de datos que asocia valores con claves. Este mapa se puede emplear como array, lista, tabla asociativa, diccionario, colección, pila, cola….

Como los valores de un array pueden ser otro arrays, podemos crear árboles y arrays multidimensionales.

Los valores no tienen porqué ser del mismo tipo de datos. Podemos crear un array donde se mezclen valores enteros con cadenas de caracteres. Incluso las claves pueden ser de diferentes tipos, como veremos más adelante.

Existen multitud de funciones en PHP para trabajar con arrays. Más adelante veremos algunas de las más útiles.

Para declarar una variable de tipo array utilizamos el constructor array(). A continuación podemos escribir directamente los valores separados por coma, o definir las claves y sus valores. Para definir pares de clave – valor, usamos la notación clave ⇒ valor.

$a = array(9,12,34,56,78);

$b = array(
    'a' => 9,
    'b' => 12,
    'c' => 34,
    'd' => 56,
    'e' => 78
);

Si utilizamos la primera forma (no definimos las claves), PHP asigna una clave de forma automática a cada elemento que será un entero dependiendo de la posición que ocupe el valor en el array, empezando por cero.

A partir de PHP 5.4 también se puede usar la sintaxis de array corta, la cual reemplazará array() por [ ].

$c = [
    'a' => 9,
    'b' => 12,
    'c' => 34,
    'd' => 56,
    'e' => 78
];

Las claves pueden ser un integer o un string. El valor puede ser de cualquier tipo (incluso otro array).

Hay que tener en cuenta los siguientes puntos para las claves:

• Un string que contenga un integer válido será convertido a integer. Por ejemplo, la clave “8” se transformará en 8. Sin embargo, la clave “08” no se convertirá en 8, ya que no es un integer válido.

• Un float eliminará la parte fraccionaria y se almacenará como la parte entera del número. Por ejemplo, la clave 7.3 se almacenará como 7.

• Un booleano también se almacenará como integer. La clave true = 1, y false = 0.

• Un clave null será almacenada como la cadena “”.

• Si varios elementos en la declaración del array usan la misma clave, sólo se utilizará la última, eliminando los demás elementos.

$d = [
    1 => 'Pepe',
    1.5 => 'María',
    true => 'Juan',
    '1' => 'Amparo'
];

El array anterior se convertirá en:

$d = [
    1 => 'Amparo'
];

Los array en PHP pueden contener claves integer y string al mismo tiempo, ya que PHP no distingue entre arrays indexados y asociativos (son todos asociativos).

$e = [
    100 => 'Pepe',
    101 => 'María',
    'foo' => 'Juan',
    'bar' => 'Amparo'
];

La clave es opcional. Si no se utiliza, PHP usará el incremento de la clave de tipo integer mayor utilizada anteriormente (si no hemos utilizado ninguna empezará por 0).

Por ejemplo, si definimos el siguiente array:

$f = array('Pepe', 'María', 'Juan', 'Amparo');

PHP lo convertirá en:

$f = [
    0 => 'Pepe',
    1 => 'María',
    2 => 'Juan',
    3 => 'Amparo'
];

Es posible especificar las claves para algunos elementos y excluir a los demás.

$f = [
    'Pepe',
    'María',
    6 => 'Juan',
    'Amparo'
];

El anterior array será equivalente a:

$f = [
    0 => 'Pepe',
    1 => 'María',
    6 => 'Juan',
    7 => 'Amparo'
];

Podemos crear arrays multidimensionales definiendo a su vez los valores como arrays.

$h = [
    [
        "nombre" => 'Pepe',
        "edad" => 25
    ],
    [
        "nombre" => 'María',
        "edad" => 36
    ]
];

Podríamos pensar en poner claves a los arrays del segundo nivel para reducir el tamaño de la siguiente forma:

$h = [
    "Pepe" => [
        "edad" => 25
    ],
    "María" => [
        "edad" => 36
    ]
];

Aunque ésto tiene un problema evidente. Ya que no se pueden repetir las claves de los arrays, si añadiésemos una nueva persona llamada María, machacaría los datos anteriores, perdiendo datos en el proceso.

Por regla general, lo mejor es crear los arrays multidimensionales de la primera forma, simulando tablas donde las claves serían enteros que nos indicaría el número de registro.

Para acceder a los elementos de un array lo hacemos mediante $array[clave].

Dependiendo de si hemos definido las claves o no, podremos utilizar números secuenciales (empezando por 0) o nuestras propias claves:

$miArray = [3, 5, 67, 9, 48];
echo $miArray[0]; # imprimirá 3
echo $miArray[2]; # imprimirá 67

$miArray = [
    "elemento1" => 2,
    "elemento2" => 5,
    "elemento3" => 67,
    "elemento4" => 9,
    "elemento5" => 48,
];
echo $miArray["elemento2"]; #imprimirá 5
echo $miArray["elemento5"]; #imprimirá 48

Para acceder a los elementos de los array multidimensionales tendremos que anidar tantas claves como niveles tenga el elemento al que queramos acceder.

$personas = [
    [
    "nombre" => "Pepe",
    "edad" => 34
    ]
];
echo $personas[0]["nombre"]; #imprimirá Pepe

Aunque se puede recorrer un array con casi cualquier bucle, PHP nos ofrece un modo sencillo para iterar sobre ellos: foreach.

Existen dos sintaxis:

foreach ($miArray as $value) {
    # code...
}
    
foreach ($miArray as $key => $value) {
    # code...
}

La diferencia es que en la primera obtenemos sólo los valores, mientras que con la segunda forma podemos acceder también a las claves del array.

Por ejemplo, si tenemos el siguiente array:

$contacto = [
    "nombre" => "Pepe",
    "edad" => 25,
    "direccion" => "C/ Alcalá, 25",
    "ciudad" => "Valencia"
];

Si recorremos el array con la primera forma:

foreach ($contacto as $value) {
    echo "$value<br>";
};

La salida será:

Mientras que si lo recorremos de la segunda forma:

foreach ($contacto as $key => $value) {
    echo "$key: $value<br>";
};

Podríamos sacar también las claves del array por pantalla:

Para unir dos array utilizamos el operador +.

$arrayA = [
    "primero" => 3,
    "segundo" => 45,
    "tercero" => 67,
    "cuarto" => 8
];

$arrayB = [
    "quinto" => 56,
    "sexto" => 98,
    "septimo" => 23,
    "octavo" => 2
];

$resultado = $arrayA + $arrayB;
var_dump($resultado);

El array $resultado sería:

Hay que tener cuidado con el operador de unión para arrays. 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.

Por ejemplo, si tenemos estos dos arrays:

$arrayA = [
    "primero" => 3,
    "segundo" => 45,
];

$arrayB = [
    "primero" => 56,
    "segundo" => 98,
    "tercer" => 23,
];

$resultado = $arrayA + $arrayB;
var_dump($resultado);

El array $resultado no contendrá 5 elementos, como podríamos pensar a priori, si no que tendría sólo 3 elementos:

Para comparar arrays podemos utilizar los mismos operadores de comparación que para el resto de tipo de datos con alguna particularidad.

Si queremos saber si dos arrays son iguales, podemos usar == (igual que podemos utilizar != para saber si son distintos), aunque puede haber alguna situación donde parezca que la comparación no funciona como debe.

Supongamos que tenemos el siguiente código:

$arrayA = [
    "primero" => 3,
    "segundo" => 45,
];
    
$arrayB = [
    "segundo" => 45,
    "primero" => 3,
];

if($arrayA == $arrayB) {
    echo "Los arrays son iguales";
} else {
    echo "Los arrays son diferentes";
}

Si vemos la salida que nos muestra el navegador, veremos que, al contrario de lo que podríamos pensar, los dos arrays son iguales:

Ésto ocurre porque el comparador == en arrays comprueba que tienen los mismos pares claves – valor, pero no el orden en el que están en cada array.

Si queremos comparar los arrays para saber si son exactamente idénticos, deberemos utilizar el operador ===.

$arrayA = [
    "primero" => 3,
    "segundo" => 45,
];

$arrayB = [
    "segundo" => 45,
    "primero" => 3,
];

if($arrayA === $arrayB) {
    echo "Los arrays son iguales";
} else {
    echo "Los arrays son diferentes";
}

Cuya salida, ahora sí, es la esperada:

De todas formas, la mayoría de veces es más útil trabajar con funciones propias de los arrays, como veremos en el apartado siguiente.

Como hemos dicho, existen muchas funciones para trabajar con arrays. En este punto veremos algunas de ellas (podéis ver todas las que hay en el manual de php).

La función count cuenta todos los elementos de un array. Podemos usar sizeof como alias de count().

$miArray = [34, 3, 65, 7, 87, 99, 3];
$longitud = count($miArray);
echo "El array tiene $longitud elementos";

La función array_push añade un elemento al final de un array.

$miArray = [34, 3, 65, 7, 87, 99, 3];
array_push($miArray, 100);
var_dump($miArray);

Podemos conseguir los mismo con array[] = nuevo_elemento.

$miArray = [34, 3, 65, 7, 87, 99, 3];
$miArray[] = 100;

La función array_values devuelve todos los valores del array y lo indexa numéricamente.

$miArray = [
    "foo" => 5,
    "bar" => 7
];
 var_dump(array_values($miArray));

La función array_keys devuelve todas las claves de un array o un subconjunto de ellas.

$miArray = [
    "foo" => 5,
    "bar" => 7
];
var_dump(array_keys($miArray));

Podemos sacar las claves de un valor si especificamos el segundo parámetro.

$miArray = [
    "foo" => 5,
    "bar" => 7
];
var_dump(array_keys($miArray, 7));

La función in_array comprueba si un valor existe en un array.

$miArray = [34, 3, 65, 7, 87, 99, 3];
if (in_array(65, $miArray)) {
    echo "El valor existe en el array";
} else {
    echo "El valor no existe en el array";
}

La función array_search busca el valor en un array y devuelve su clave.

$miArray = [
    "foo" => 5,
    "bar" => 7,
    "pre" => 18,
    "dig" => 56
];
$clave = array_search(7, $miArray);
echo "La clave del elemento 7 es $clave";

La función array_key_exists comprueba si la clave existe en el array. Podemos utilizar el alias key_exists.

$miArray = [
    "foo" => 5,
    "bar" => 7,
    "pre" => 18,
    "dig" => 56
];
if (array_key_exists("dig", $miArray)) {
    echo "La clave dig existe en el array";
} else {
    echo "La clave dig no existe en el array";
}

La función sort ordena un array de menor a mayor.

$frutas = array("limón", "naranja", "banana", "albaricoque");
sort($frutas);
var_dump($frutas);

La función array_merge combina los elementos de uno o más arrays juntándolos de modo que los valores de uno se anexan al final del anterior. Los valores del array de entrada con claves numéricas serán renumeradas con claves incrementales en el array resultante, comenzando desde cero.

$arrayA = [3, 45, 67, 89];
$arrayB = [4, 65, 34, 98, 45];
$resultado = array_merge($arrayA, $arrayB);
var_dump($resultado);

Si los arrays de entrada tienen las mismas claves de tipo string, el último valor para esa clave sobrescribirá al anterior.

$arrayA = [
    "primero" => 3,
    "segundo" => 45,
];
$arrayB = [
    "primero" => 56,
    "segundo" => 98,
    "tercera" => 23,
];
$resultado = array_merge($arrayA, $arrayB);
var_dump($resultado);

La función array_diff compara array1 con uno o más arrays y devuelve los valores de array1 que no estén presentes en ninguno de los otros arrays.

$arrayA = ["green", "red", "blue", "red"];
$arrayB = ["green", "yellow", "red"];
$resultado = array_diff($arrayA, $arrayB);
var_dump($resultado);

Ejercicio 1

Escribe un programa en PHP que genere un array de un número aleatorio de valores numéricos (entre 5 y 15). Los valores se encontraran entre 0 y 10, también obtenidos de forma aleatoria.

Salida:

Ejercicio 2

Crea un archivo PHP que almacene en un array la tabla de multiplicar del 7. El programa deberá sacar por pantalla dicha tabla.

Ejercicio 3

Modifica el ejercicio anterior para que se almacene en una matriz las tablas de multiplicar del 1 al 9 y las muestre por pantalla.

Ejercicio 4

Una empresa quiere actualizar su gestión de almacén. Hasta ahora, iban apuntando en una hoja de cálculo el material que quedaba después de retirarlo de las estanterías (si no se retiraba algún material, no se apuntaba ese mes). Los datos de los dos meses que lleva abierta son:

Mayo:

• Tornillos = 57
• Tuercas = 23
• Clavos = 45
• Arandelas = 56
• Muelles = 32

Junio:

• Tornillos = 32
• Arandelas = 51
• Bridas = 309

Hacer un programa en PHP para que nos muestre el total de material que queda en junio en el almacén.

Ejercicio 5

Un restaurante quiere añadir el postre a todos sus menús (actualmente tienen menús con y sin postre). En su web, hecha con PHP, tienen el siguiente array con los diferentes menús:

$menus = [
    [
        "primero" => "sopa",
        "segundo" => "carne",
        "postre" => "tarta"
    ],
    [
        "primero" => "ensalada",
        "segundo" => "carne",
    ],
    [
        "primero" => "macarrones",
        "segundo" => "pescado",
    ],
    [
        "primero" => "sopa",
        "segundo" => "pescado",
        "postre" => "flan"
    ],
];

Escribe el código necesario para que, de forma lo más eficiente posible, nos muestre los menús que no tienen postre actualmente (los menús se numeran de forma correlativa empezando por el 1).

Ejercicio 6

Dado los dos siguientes arrays:

$array1 = [34, 56, 78, 8, 98, 33, 45];
$array2 = [56, 76, 2, 68, 77, 25, 15];

Escribir un programa en PHP que combine ambos arrays (con elemento repetidos si los hubiera) y los ordene de mayor a menor.

Ejercicio 7

Crea un fichero PHP llamado ejercicio7a.php con el siguiente contenido:

$empleados = [
    [
        "nombre" => "Juan",
        "edad" => 34,
    ],
    [
        "nombre" => "María",
        "edad" => 22
    ],
    [
        "nombre" => "Ángeles",
        "edad" => 45
    ],
    [
        "nombre" => "Pepe",
        "edad" => 34,
    ],
    [
        "nombre" => "Mario",
        "edad" => 57
    ]
];

En otro fichero llamado ejercicio7b.php, escribe un programa PHP que muestre por pantalla el nombre y la edad del empleado más joven y del más mayor.