Arrays en PHP: indexados, asociativos y multidimensionales con ejemplos prácticos

Hasta ahora trabajamos con variables que guardaban un solo valor. Pero en muchas situaciones necesitamos almacenar varios datos relacionados dentro de una misma estructura.

Para eso PHP utiliza los arrays. Son fundamentales porque aparecen constantemente en formularios, resultados de bases de datos, APIs, configuraciones y colecciones de objetos.

¿Qué es un array?

Un array es una estructura que permite guardar varios valores dentro de una misma variable.

En lugar de hacer esto:

$color1 = 'rojo';
$color2 = 'verde';
$color3 = 'azul';

podemos agruparlos:

$colores = ['rojo', 'verde', 'azul'];

Ahora $colores contiene tres elementos.

Array indexado

Un array indexado utiliza posiciones numéricas para identificar cada elemento.

$frutas = ['Manzana', 'Pera', 'Naranja'];

PHP comienza los índices numéricos en 0.

0 → Manzana
1 → Pera
2 → Naranja

Acceder a un elemento

$frutas = ['Manzana', 'Pera', 'Naranja'];

echo $frutas[0];

Resultado:

Manzana

Modificar un elemento

$frutas[1] = 'Banana';

Ahora el array contiene:

Manzana
Banana
Naranja

Agregar elementos

La forma más simple es utilizar corchetes vacíos:

$frutas[] = 'Kiwi';

PHP agrega el nuevo valor al final del array.

Array asociativo

Un array asociativo utiliza claves con significado en lugar de índices numéricos.

$persona = [
    'nombre' => 'Ana',
    'edad' => 25,
    'ciudad' => 'Santa Rosa'
];

En este caso las claves son:

nombre
edad
ciudad

Acceder por clave

echo $persona['nombre'];

Resultado:

Ana

Modificar un valor asociativo

$persona['edad'] = 26;

Agregar una nueva clave

$persona['email'] = 'ana@email.com';

Clave y valor

En un array asociativo cada elemento se compone de dos partes:

clave => valor

Por ejemplo:

'nombre' => 'Ana'

La clave identifica el dato y el valor contiene la información.

Arrays multidimensionales

Un array puede contener otros arrays.

$usuarios = [
    [
        'nombre' => 'Ana',
        'edad' => 25
    ],
    [
        'nombre' => 'Juan',
        'edad' => 31
    ]
];

Esto permite representar estructuras más complejas.

Acceder a un array multidimensional

echo $usuarios[0]['nombre'];

Resultado:

Ana

Primero seleccionamos el elemento 0 del array principal y luego la clave nombre.

Ejemplo real: productos

$productos = [
    [
        'nombre' => 'Teclado',
        'precio' => 25000,
        'stock' => 10
    ],
    [
        'nombre' => 'Mouse',
        'precio' => 15000,
        'stock' => 25
    ]
];

Este formato es muy parecido a la información que luego podemos obtener desde una base de datos.

Recorrer arrays con foreach

foreach es la estructura más cómoda para recorrer arrays.

$frutas = ['Manzana', 'Pera', 'Naranja'];

foreach ($frutas as $fruta) {
    echo $fruta . '
';
}

Recorrer clave y valor

foreach ($persona as $clave => $valor) {
    echo $clave . ': ' . $valor . '
';
}

Recorrer arrays multidimensionales

foreach ($productos as $producto) {
    echo $producto['nombre'] . ' - $' . $producto['precio'] . '
';
}

count()

count() devuelve la cantidad de elementos de un array.

$frutas = ['Manzana', 'Pera', 'Naranja'];

echo count($frutas);

Resultado:

3

in_array()

in_array() permite saber si un valor existe dentro de un array.

$roles = ['admin', 'editor', 'usuario'];

if (in_array('admin', $roles, true)) {
    echo 'Existe el rol admin';
}

El tercer parámetro true solicita comparación estricta.

array_key_exists()

En arrays asociativos podemos comprobar si existe una clave.

if (array_key_exists('email', $persona)) {
    echo $persona['email'];
}

isset() y una diferencia importante

isset() también suele utilizarse para comprobar datos:

if (isset($persona['email']))) {
    echo 'Existe y no es NULL';
}

Pero isset() devuelve falso si la clave existe y su valor es null. array_key_exists(), en cambio, verifica la existencia de la clave independientemente de su valor.

Eliminar elementos con unset()

$frutas = ['Manzana', 'Pera', 'Naranja'];

unset($frutas[1]);

El elemento se elimina, pero PHP no necesariamente reordena automáticamente los índices existentes.

Agregar con array_push()

array_push($frutas, 'Kiwi');

Aunque funciona, para agregar un único elemento suele ser más simple:

$frutas[] = 'Kiwi';

array_pop()

Elimina y devuelve el último elemento.

$ultimo = array_pop($frutas);

array_shift()

Elimina y devuelve el primer elemento.

$primero = array_shift($frutas);

array_unshift()

Agrega uno o más elementos al comienzo.

array_unshift($frutas, 'Frutilla');

Ordenar arrays

sort()

Ordena un array indexado de menor a mayor.

$numeros = [5, 2, 9, 1];

sort($numeros);

rsort()

Ordena en sentido descendente.

rsort($numeros);

Ordenar arrays asociativos

asort() ordena por valor manteniendo la relación con las claves.

$precios = [
    'teclado' => 25000,
    'mouse' => 15000,
    'monitor' => 180000
];

asort($precios);

ksort() ordena por clave.

ksort($precios);

array_merge()

Permite combinar arrays.

$grupo1 = ['Ana', 'Juan'];
$grupo2 = ['Lucía', 'Pedro'];

$todos = array_merge($grupo1, $grupo2);

implode()

implode() convierte un array en un string utilizando un separador.

$nombres = ['Ana', 'Juan', 'Lucía'];

$texto = implode(', ', $nombres);

echo $texto;

Resultado:

Ana, Juan, Lucía

explode()

explode() realiza la operación inversa: separa un string y devuelve un array.

$texto = 'Ana,Juan,Lucía';

$nombres = explode(',', $texto);

array_map()

array_map() permite transformar cada elemento de un array.

$numeros = [1, 2, 3, 4];

$dobles = array_map(function ($numero) {
    return $numero * 2;
}, $numeros);

El resultado será:

[2, 4, 6, 8]

¿Qué es un callback?

En el ejemplo anterior, array_map() recibe una función que PHP ejecutará para cada elemento.

A una función que se entrega a otra función para que sea ejecutada posteriormente se la suele llamar callback.

Más adelante veremos funciones con mayor profundidad.

array_filter()

array_filter() permite conservar únicamente los elementos que cumplen una condición.

$numeros = [1, 2, 3, 4, 5, 6];

$pares = array_filter($numeros, function ($numero) {
    return $numero % 2 === 0;
});

Ejemplo práctico: filtrar productos con stock

$productos = [
    ['nombre' => 'Teclado', 'stock' => 10],
    ['nombre' => 'Mouse', 'stock' => 0],
    ['nombre' => 'Monitor', 'stock' => 5]
];

$disponibles = array_filter($productos, function ($producto) {
    return $producto['stock'] > 0;
});

Ahora $disponibles contiene solamente productos con stock.

Acceso seguro con ??

Cuando una clave puede no existir, podemos usar el operador ??.

$telefono = $persona['telefono'] ?? 'Sin teléfono';

Si la clave no existe o contiene null, se utiliza el valor alternativo.

Arrays y datos de formularios

Cuando trabajemos con formularios veremos variables como:

$_GET
$_POST
$_FILES
$_SESSION

Varias de estas estructuras son arrays asociativos proporcionados por PHP.

Por eso dominar arrays es fundamental antes de avanzar hacia formularios y aplicaciones reales.

Arrays y bases de datos

Cuando consultamos una base de datos desde PHP, es habitual recibir resultados con una estructura similar a:

[
    ['id' => 1, 'nombre' => 'Ana'],
    ['id' => 2, 'nombre' => 'Juan']
]

Luego podemos recorrer esos registros con foreach.

Errores comunes

• olvidar que los arrays indexados comienzan en 0;
• intentar acceder a una clave que no existe;
• confundir índice con valor;
• usar sort() sobre un array asociativo cuando queremos conservar sus claves;
• no diferenciar isset() de array_key_exists();
• crear estructuras multidimensionales innecesariamente complejas;
• modificar un array sin comprender cómo afecta sus índices.

Buenas prácticas

• usar claves descriptivas;
• mantener estructuras consistentes;
• usar foreach para recorrer colecciones;
• comprobar claves opcionales antes de acceder;
• evitar demasiados niveles de anidación;
• utilizar funciones de arrays cuando expresen mejor la intención del código.

Ejercicios

1. crear un array con cinco nombres y recorrerlo;
2. mostrar el tercer elemento de un array indexado;
3. crear un array asociativo con nombre, edad y email;
4. agregar una nueva clave al array;
5. crear un array de productos con nombre, precio y stock;
6. recorrer productos con foreach;
7. contar productos utilizando count();
8. comprobar si existe un valor con in_array();
9. comprobar una clave con array_key_exists();
10. ordenar números ascendente y descendentemente;
11. convertir un array de nombres a texto con implode();
12. convertir un texto separado por comas en array con explode();
13. duplicar números utilizando array_map();
14. filtrar números pares con array_filter();
15. filtrar productos con stock mayor a cero.

Qué aprendimos

• qué es un array;
• arrays indexados;
• arrays asociativos;
• arrays multidimensionales;
• clave y valor;
• recorrido con foreach;
• count();
• in_array();
• array_key_exists();
• isset();
• ordenamiento;
• array_merge();
• implode() y explode();
• array_map() y array_filter();
• callbacks;
• relación de los arrays con formularios y bases de datos.

¿Qué sigue?

En la próxima guía veremos funciones en PHP: cómo crear nuestras propias funciones, parámetros, valores de retorno, alcance de variables y tipado.

¿Te sirvió esta guía? ☕

Si este contenido te ayudó y querés apoyar a Club Programador, podés colaborar mediante:

☕ Apoyar con Mercado Pago

🌎 Apoyar con PayPal