Arrays en PHP — Guía completa y detallada

Resumen: Esta guía cubre desde los conceptos básicos hasta temas avanzados sobre arrays en PHP. Incluye ejemplos comentados, funciones comunes, buenas prácticas, rendimiento y ejercicios para practicar.

---

Índice

1. ¿Qué es un array?
2. Cómo crear arrays
3. Acceder y modificar elementos
4. Iterar arrays
5. Funciones útiles (con ejemplos)
6. Ordenar arrays
7. Arrays multidimensionales
8. Arrays asociativos con ejemplos prácticos
9. Operaciones comunes: merge, slice, splice, chunk
10. Referencias y copy-on-write
11. Convertir arrays: JSON, strings y objetos
12. Rendimiento y memoría (tips)
13. Herramientas y estructuras alternativas
14. Errores comunes y cómo evitarlos
15. Ejercicios prácticos
16. Resumen y buenas prácticas

---

¿Qué es un array?

Un array es una estructura de datos que almacena múltiples valores en una sola variable. En PHP, los arrays son heterogéneos (pueden contener diferentes tipos) y dinámicos (puedes añadir o quitar elementos en tiempo de ejecución).

PHP implementa arrays con asociative arrays internamente — es decir, cada elemento tiene una clave (key) que puede ser un entero o una cadena, y un valor (value).

---

Cómo crear arrays

Sintaxis moderna (short array syntax)

<?php
$frutas = ["Manzana", "Banana", "Naranja"];

Sintaxis antigua (array())

<?php
$frutas = array("Manzana", "Banana", "Naranja");

Arrays asociativos (claves personalizadas)

<?php
$persona = [
    "nombre" => "Andrés",
    "edad" => 30,
    "ciudad" => "Lima"
];

Arrays vacíos y añadir elementos

Acceder y modificar elementos

Acceder por índice / clave

<?php
echo $frutas[0];           // Manzana
echo $persona["nombre"];   // Andrés

Modificar

<?php
$frutas[1] = "Pera";       // reemplaza Banana por Pera
$persona["edad"] = 31;

Añadir con llave específica

<?php
$datos["telefono"] = "987654321";

Eliminar elementos

<?php
unset($frutas[2]);         // elimina Naranja (la clave 2)

Nota: unset() elimina la clave. Si trabajas con índices numéricos, la reindexación no ocurre automáticamente (usa array_values() si quieres reindexar).

---

Iterar arrays

foreach (recomendado)

<?php
foreach ($frutas as $index => $valor) {
    echo "$index => $valor
";
}

foreach por referencia (modificar valores)

<?php
foreach ($frutas as &$valor) {
    $valor = strtoupper($valor);
}
unset($valor); // muy importante: eliminar la referencia al final

Si olvidas unset($valor) tras usar la referencia, la variable seguirá referenciando el último elemento y puede causar bugs.

for con count

<?php
for ($i=0, $n = count($frutas); $i < $n; $i++) {
    echo $frutas[$i];
}

while con each (no recomendado)

each() fue deprecated y eliminada en versiones recientes — usa foreach o ArrayIterator.

---

Funciones útiles (con ejemplos)

Nota: hay muchas funciones; aquí están las más usadas y prácticas.

Información y tamaño

• count($arr) o sizeof($arr) — número de elementos.

<?php
echo count($frutas); // 3

Añadir / quitar

• array_push($arr, $val) — añade al final (devuelve nuevo tamaño).
• array_pop($arr) — elimina y devuelve el último elemento.
• array_unshift($arr, $val) — añade al inicio.
• array_shift($arr) — elimina y devuelve el primer elemento.

<?php
array_push($frutas, "Kiwi");
$ultimo = array_pop($frutas);

Buscar / comprobar

• in_array($needle, $haystack) — busca valor.
• array_search($needle, $haystack) — devuelve clave o false.
• array_key_exists($key, $arr) — comprueba si existe la clave.
• isset($arr[$key]) — similar pero false si la clave existe y es null.

<?php
if (in_array("Pera", $frutas)) { echo "existe"; }
$key = array_search("Pera", $frutas); // 1

Transformación y filtrado

• array_map($callback, $arr) — aplica una función a cada elemento y devuelve nuevo array.
• array_filter($arr, $callback) — devuelve elementos que cumplan la condición.
• array_reduce($arr, $callback, $initial) — reduce en un único valor.
• array_walk($arr, $callback) — aplica función a cada elemento (no devuelve nuevo array, actúa en sitio o por referencia).

<?php
$mayus = array_map('strtoupper', $frutas);
$pares = array_filter([1,2,3,4,5], fn($v) => $v % 2 === 0);
$sum = array_reduce([1,2,3,4], fn($carry,$v) => $carry + $v, 0);

Claves y valores

• array_keys($arr) — devuelve array de claves.
• array_values($arr) — devuelve array de valores.
• array_key_first($arr) / array_key_last($arr) — (PHP 7.3+) obtienen la primera/ultima clave.

Combinación y unión

• array_merge($a, $b) — une arrays; reindexa claves numéricas.
• array_merge_recursive($a, $b) — combina recursivamente.
• $union = $a + $b — unión por claves (preserva claves del primer array).
• array_combine($keys, $values) — crea array combinando claves y valores (ambos arrays deben tener mismo tamaño).

<?php
$a = [0 => "cero", 1 => "uno"];
$b = [0 => "A", 2 => "dos"];
print_r(array_merge($a, $b)); // reindexa
print_r($a + $b); // conserva claves del $a

Reindexar

• array_values($arr) — devuelve array con índices numéricos reindexados desde 0.

Extra

• array_slice, array_splice, array_chunk, array_rand, shuffle, array_unique, array_sum, array_product, array_count_values, array_column, array_flip.

<?php
$parte = array_slice($frutas, 1, 2); // obtiene subarray
array_splice($frutas, 1, 1, ["Pera", "Melón"]); // reemplaza
$chunks = array_chunk($frutas, 2);

---

Ordenar arrays

Importante: algunas funciones preservan las claves y otras no.

• sort($arr) — ordena valores, reindexa claves.
• rsort($arr) — orden descendente.
• asort($arr) — ordena manteniendo relación clave=>valor (preserva claves).
• arsort($arr) — como asort en orden descendente.
• ksort($arr) — ordena por claves (ascendente).
• krsort($arr) — por claves (descendente).
• usort($arr, $callback) — ordena usando función de comparación (no preserva claves).
• uasort($arr, $callback) — orden por valores con callback y preserva claves.

Ejemplo — ordenar asociativo por valores manteniendo claves:

<?php
$productos = ["a" => 10, "b" => 5, "c" => 8];
asort($productos); // b=>5, c=>8, a=>10 (claves preservadas)

Ejemplo — usort para objetos

<?php
$usuarios = [
    ["name" => "Ana", "edad" => 30],
    ["name" => "Luis", "edad" => 25],
];
usort($usuarios, fn($a,$b) => $a['edad'] <=> $b['edad']); // ordena por edad

---

Arrays multidimensionales

Un array puede contener arrays (matrices / tablas).

<?php
$matriz = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
];

echo $matriz[1][2]; // 6

Ejemplo con claves

<?php
$usuarios = [
    ["id"=>1, "name"=>"Ana"],
    ["id"=>2, "name"=>"Luis"],
];
echo $usuarios[0]['name']; // Ana

Recorrer con foreach anidado

<?php
foreach ($matriz as $fila) {
    foreach ($fila as $valor) {
        echo $valor;
    }
}

array_column — extraer columna

<?php
$names = array_column($usuarios, 'name'); // ["Ana", "Luis"]

---

Arrays asociativos — ejemplos prácticos

Representar una entidad (DTO simple)

<?php
$producto = [
    "id" => 10,
    "nombre" => "Camiseta",
    "precio" => 29.90
];

Guardar usuarios por id (acceso rápido)

<?php
$usersById = [
    101 => ["name"=>"Ana"],
    102 => ["name"=>"Luis"]
];

echo $usersById[101]['name']; // Ana

Actualizar en sitio

<?php
$usersById[101]['email'] = "ana@example.com";

---

Operaciones comunes: merge, slice, splice, chunk

• array_merge($a, $b) — combine arrays.
• array_slice($arr, $offset, $length) — copia parcial sin modificar original.
• array_splice(&$arr, $offset, $length, $replacement) — modifica el array original.
• array_chunk($arr, $size) — divide en bloques.

<?php
$a = [1,2,3,4,5];
$b = array_slice($a, 1, 3); // [2,3,4]
array_splice($a, 1, 2); // $a ahora [1,4,5]

---

Referencias y copy-on-write

En PHP, la asignación de arrays usa copy-on-write: asignar un array a otra variable no duplica memoria hasta que uno de los dos se modifica.

<?php
$a = [1,2,3];
$b = $a;      // no copia inmediatamente (copy-on-write)
$b[0] = 99;   // ahora PHP hace la copia y modifica $b

Referencias explícitas

<?php
$a = [1,2,3];
$b = &$a;     // $b referencia a $a
$b[0] = 99;
echo $a[0];   // 99

Usa referencias con cuidado: pueden causar código difícil de mantener.

---

Convertir arrays: JSON, strings y objetos

JSON

<?php
$json = json_encode($producto);
$array = json_decode($json, true); // true devuelve array asociativo

Implode / Explode (strings)

<?php
$csv = implode(",", $frutas); // "Manzana,Pera, ..."
$parts = explode(",", $csv);

Serializar

<?php
$s = serialize($producto);
$orig = unserialize($s);

Array <-> Object

<?php
$std = (object) $producto;        // array a objeto stdClass
$arr = (array) $std;              // objeto a array

---

Rendimiento y memoría (tips)

• PHP usa copy-on-write: asignar arrays es barato hasta que los modificas.
• Para colecciones muy grandes, considera usar generators (yield) para procesar elemento a elemento sin cargar todo en memoria.
• SplFixedArray puede usar menos memoria si el tamaño es fijo, pero su uso es menos común y la API es distinta.
• Evita foreach con count() en la condición sin almacenarla en variable si el array puede cambiar en cada iteración. Mejor hacer $n = count($arr) antes.

Ejemplo de generator

<?php
function iterarLineas($file) {
    $f = fopen($file, 'r');
    while (($line = fgets($f)) !== false) {
        yield $line;
    }
    fclose($f);
}

foreach (iterarLineas('archivo.txt') as $line) {
    // procesa línea sin cargar todo el archivo
}

---

Herramientas y estructuras alternativas

• ArrayObject y ArrayIterator — objetos que envuelven arrays y permiten métodos de iteración y manipulación.
• SplFixedArray — array de tamaño fijo (menor consumo de memoria en algunos casos).
• Generators (yield) — recorrer grandes conjuntos sin memorizarlos.

---

Errores comunes y cómo evitarlos

1. Olvidar unset($var) después de foreach(&$v) — produce referencias indeseadas.
2. Usar array_merge creyendo que preservará claves numéricas — array_merge reindexa claves numéricas.
3. Modificar un array mientras se itera sobre él — puede producir comportamiento impredecible.
4. Confundir isset() y array_key_exists() — isset() devuelve false si la clave existe y su valor es null.
5. Olvidar validar datos al usar array_combine() — ambos arrays deben tener el mismo tamaño.

---

Ejercicios prácticos (con pistas)

1. Invertir array: escribir función que reciba array y devuelva mismo array invertido sin usar array_reverse().

   • Pista: recorre desde el final al inicio.

2. Contar palabras: dada una cadena, contar cuántas veces aparece cada palabra (uso de explode() y array_count_values()).

3. Agrupar por propiedad: dado array de usuarios con ['id','name','city'], agruparlos por city (resultado: ['Lima' => [user1,user2], 'Cusco'=>[...]]).

4. Merge sin perder claves: combinar dos arrays asociativos sin que las claves del primer array se sobrescriban (usa el operador +).

5. Filtrar duplicados por campo: dada lista de arrays (usuarios) eliminar duplicados por email conservando el primero.

---

Utilidades de depuración

• var_dump($arr) — muestra estructura con tipos.
• print_r($arr) — formato legible.
• var_export($arr, true) — devuelve código PHP que representa el array.
• Usa Xdebug para inspección avanzada.

---

Resumen y buenas prácticas

• Usa arrays para almacenar colecciones; elige indexado o asociativo según el caso.
• Prefiere foreach para iterar por claridad.
• Valida datos antes de usar funciones que requieren tamaños/formatos (ej. array_combine).
• Para grandes volúmenes, considera yield o estructuras más eficientes.
• Conoce las reglas de reindexado y preservación de claves al usar funciones como array_merge, sort, asort.
• Evita referencias innecesarias; cuando las uses, libera la referencia con unset().

---

Referencias rápidas (funciones más usadas)

• count(), in_array(), array_search(), array_key_exists(), isset(), array_keys(), array_values(), array_map(), array_filter(), array_reduce(), array_push(), array_pop(), array_shift(), array_unshift(), array_merge(), array_slice(), array_splice(), array_chunk(), array_column(), array_unique(), array_sum(), array_reverse().

---

¿Quieres que guarde este contenido en un archivo .md para descargarlo? Puedo:

• Guardarlo como arrays-en-php-completo.md y darte el enlace de descarga, o
• Convertirlo a HTML listo para tu CMS (con meta tags).