Arrays en PHP: funciones esenciales con ejemplos

PHP trae más de setenta funciones que empiezan por array_, además de otras como sort(), in_array() o count(). Nadie las usa todas. En el día a día, una docena resuelve casi cualquier problema, y lo que marca la diferencia es conocer sus detalles: cuáles conservan las claves, cuáles modifican el array original y cuáles comparan con == en lugar de ===.

Este artículo está organizado como un fichero de consulta. Cada ficha explica para qué sirve la función, muestra un ejemplo y señala la trampa más habitual. Todos los ejemplos funcionan en PHP 8.

Un recordatorio rápido: el array de PHP es lista y diccionario

En PHP, un array es un mapa ordenado de claves a valores. Las claves pueden ser enteros o strings. Cuando no indicas claves, PHP usa 0, 1, 2… y el array se comporta como una lista. Cuando las indicas, funciona como un diccionario. La misma estructura sirve para ambas cosas, y por eso algunas funciones «renumeran» claves y otras no.

<?php
$lista = ['rojo', 'verde', 'azul'];              // claves 0, 1, 2
$mapa  = ['co' => 'Colombia', 'mx' => 'México'];  // claves de texto

// array_is_list() (PHP 8.1+) indica si las claves son 0..n-1 en orden
var_dump(array_is_list($lista)); // true
var_dump(array_is_list($mapa));  // false

Para los ejemplos usaremos este array de productos:

<?php
$productos = [
    ['id' => 1, 'nombre' => 'Teclado',  'categoria' => 'perifericos', 'precio' => 120000, 'stock' => 4],
    ['id' => 2, 'nombre' => 'Monitor',  'categoria' => 'pantallas',   'precio' => 750000, 'stock' => 0],
    ['id' => 3, 'nombre' => 'Mouse',    'categoria' => 'perifericos', 'precio' => 45000,  'stock' => 12],
    ['id' => 4, 'nombre' => 'Portátil', 'categoria' => 'equipos',     'precio' => 2900000,'stock' => 2],
];

Fichas para buscar

in_array() y array_search()

Para qué: saber si un valor está en el array (in_array) o en qué clave está (array_search).

Trampa: por defecto comparan con ==. Pasa siempre true como tercer argumento para comparar también el tipo.

<?php
$codigos = ['10', '20', '30'];

var_dump(in_array(10, $codigos));        // true: compara "10" == 10
var_dump(in_array(10, $codigos, true));  // false: int no es string

// array_search devuelve la clave o false; usa !== para no confundir la clave 0 con false
$pos = array_search('10', $codigos, true);
if ($pos !== false) {
    echo "Encontrado en la posición $pos"; // posición 0
}

isset() frente a array_key_exists()

Para qué: comprobar si existe una clave.

Trampa: isset($a['clave']) devuelve false si la clave existe pero su valor es null. array_key_exists() responde solo a si la clave está.

<?php
$opciones = ['tema' => null];

var_dump(isset($opciones['tema']));              // false
var_dump(array_key_exists('tema', $opciones));   // true

array_find(), array_any() y array_all()

Para qué: buscar el primer elemento que cumple una condición o comprobar si alguno o todos la cumplen, sin escribir un foreach.

Trampa: existen solo desde PHP 8.4. En versiones anteriores tendrás un error de función no definida.

<?php
// PHP 8.4+: la función de retorno recibe el valor y la clave
$agotado = array_find($productos, fn(array $p) => $p['stock'] === 0);
echo $agotado['nombre']; // Monitor

$hayCaros  = array_any($productos, fn(array $p) => $p['precio'] > 1000000); // true
$todosConId = array_all($productos, fn(array $p) => isset($p['id']));       // true

Fichas para transformar

array_map()

Para qué: aplicar una función a cada elemento y obtener un array nuevo con los resultados.

Trampa: con un solo array conserva las claves; con varios arrays, las pierde. Además, el orden de los argumentos es función primero, array después (al revés que array_filter).

<?php
// Precios con IVA del 19 %, redondeados a pesos enteros
$conIva = array_map(
    fn(array $p) => (int) round($p['precio'] * 1.19),
    $productos
);
// [142800, 892500, 53550, 3451000]

array_filter()

Para qué: quedarte con los elementos que cumplen una condición.

Trampa: conserva las claves originales. Si filtras una lista y luego accedes a $resultado[0], puede que esa clave ya no exista. Envuelve el resultado en array_values() si necesitas una lista limpia.

<?php
$disponibles = array_filter($productos, fn(array $p) => $p['stock'] > 0);
// Claves resultantes: 0, 2, 3 (la 1 desapareció)

$disponibles = array_values($disponibles); // ahora 0, 1, 2

// Sin función de retorno, elimina los valores "falsos": 0, '', null, false, '0', []
$limpio = array_filter(['a', '', null, 'b', '0']); // [0 => 'a', 3 => 'b']

// Para filtrar por clave, usa el modo ARRAY_FILTER_USE_KEY
$datos   = ['nombre' => 'Ana', 'clave' => 'secreta', 'email' => 'ana@ejemplo.com'];
$publico = array_filter($datos, fn(string $k) => $k !== 'clave', ARRAY_FILTER_USE_KEY);

Observa el caso de '0': el string «0» se considera falso y se elimina. Si tus datos pueden contener ceros válidos, pasa siempre una función explícita.

array_reduce()

Para qué: reducir un array a un único valor (un total, un máximo, un texto).

<?php
// Valor total del inventario: precio por existencias
$valorInventario = array_reduce(
    $productos,
    fn(int $acumulado, array $p) => $acumulado + $p['precio'] * $p['stock'],
    0 // valor inicial: sin él, el primer acumulado sería null
);

array_column()

Para qué: extraer una «columna» de un array de registros, y opcionalmente indexarla por otra.

<?php
$nombres = array_column($productos, 'nombre');
// ['Teclado', 'Monitor', 'Mouse', 'Portátil']

$precioPorId = array_column($productos, 'precio', 'id');
// [1 => 120000, 2 => 750000, 3 => 45000, 4 => 2900000]

// Con null como columna obtienes los registros completos, indexados por id
$porId = array_column($productos, null, 'id');
echo $porId[3]['nombre']; // Mouse

array_column() es de las funciones más infravaloradas. Indexar por id una sola vez convierte búsquedas repetidas con foreach en accesos directos.

Fichas para ordenar

PHP tiene una familia de funciones de ordenación que se distinguen por dos preguntas: ¿ordenan por valor o por clave? ¿conservan la relación clave-valor? Todas modifican el array original y devuelven true, no el array ordenado.

Función	Ordena por	Conserva claves	Criterio
sort() / rsort()	valor	no (renumera)	ascendente / descendente
asort() / arsort()	valor	sí	ascendente / descendente
ksort() / krsort()	clave	sí	ascendente / descendente
usort()	valor	no	tu función de comparación
uasort()	valor	sí	tu función de comparación
uksort()	clave	sí	tu función de comparación

Para ordenar registros, combina usort() con el operador nave espacial <=>, que devuelve -1, 0 o 1:

<?php
// Por categoría ascendente y, dentro de cada una, por precio descendente
usort($productos, function (array $a, array $b): int {
    return [$a['categoria'], $b['precio']] <=> [$b['categoria'], $a['precio']];
});

El truco de comparar arrays de dos elementos con <=> evita escribir varios if. Para invertir un criterio, intercambia $a y $b solo en esa posición, como se hizo con el precio. Desde PHP 8.0 la ordenación es estable: los elementos que comparan igual mantienen su orden relativo.

Un error muy común es escribir $ordenados = sort($lista);. Eso guarda true en $ordenados, no la lista.

Fichas para combinar y recortar

array_merge(), el operador + y el operador …

Los tres unen arrays, pero se comportan distinto con las claves repetidas:

<?php
$base   = ['color' => 'azul', 'talla' => 'M', 0 => 'x'];
$cambio = ['color' => 'rojo', 0 => 'y'];

print_r(array_merge($base, $cambio));
// color => rojo, talla => M, 0 => x, 1 => y
// Las claves de texto se sobrescriben; las numéricas se renumeran y se agregan

print_r($base + $cambio);
// color => azul, talla => M, 0 => x
// El operador + conserva el valor de la IZQUIERDA y nunca sobrescribe

print_r([...$base, ...$cambio]);
// Igual que array_merge; con claves de texto funciona desde PHP 8.1

Para configuraciones con valores por defecto, $opciones + $porDefecto es una forma limpia de rellenar lo que falte sin pisar lo que el usuario indicó.

array_slice() y array_splice()

array_slice() devuelve una porción sin tocar el original; array_splice() quita elementos del original (y opcionalmente inserta otros). La diferencia de una letra causa más de un error.

<?php
$letras = ['a', 'b', 'c', 'd', 'e'];

$primeras = array_slice($letras, 0, 3); // ['a', 'b', 'c']; $letras no cambia

array_splice($letras, 1, 2);            // elimina 'b' y 'c'
// $letras ahora es ['a', 'd', 'e']

array_chunk() y array_unique()

array_chunk($lista, 100) divide en bloques, útil para insertar registros en lotes. array_unique() elimina duplicados conservando la primera aparición y sus claves, así que de nuevo puede requerir array_values().

Problema resuelto: agrupar y totalizar por categoría

Supón que necesitas un resumen con el número de productos y el valor de inventario de cada categoría, ordenado de mayor a menor valor. Así se combinan varias de las fichas anteriores:

<?php
declare(strict_types=1);

$resumen = [];

foreach ($productos as $p) {
    $cat = $p['categoria'];

    // ??= inicializa la categoría solo la primera vez que aparece
    $resumen[$cat] ??= ['productos' => 0, 'valor' => 0];

    $resumen[$cat]['productos']++;
    $resumen[$cat]['valor'] += $p['precio'] * $p['stock'];
}

// uasort: ordena por valor descendente sin perder el nombre de la categoría (la clave)
uasort($resumen, fn(array $a, array $b): int => $b['valor'] <=> $a['valor']);

foreach ($resumen as $categoria => $datos) {
    printf("%-12s %d productos  $%s\n", $categoria, $datos['productos'], number_format($datos['valor'], 0, ',', '.'));
}

Fíjate en que aquí un foreach es más legible que encadenar array_reduce(). Las funciones de arrays no siempre son la mejor opción: úsalas cuando expresen la intención con claridad, y vuelve al bucle cuando necesites varios pasos por elemento.

Antes de cerrar la pestaña, quédate con estas cuatro preguntas que conviene hacerse ante cualquier función de arrays: ¿conserva las claves?, ¿modifica el original?, ¿compara con == o con ===? y ¿en qué versión de PHP apareció? La respuesta está siempre en la página de la función en el manual oficial, en las secciones de valores devueltos y de historial de cambios.