Función array_reduce() de PHP: La Guía Definitiva

array_reduce() recorre un array elemento a elemento y lo reduce a un único valor: una suma, un conteo, el elemento más grande, una estructura reconstruida, etc. En cada iteración pasa dos cosas al callback: el resultado acumulado hasta ese momento (el acumulador, convencionalmente llamado $carry) y el elemento actual ($item). Lo que devuelva el callback se convierte en el nuevo acumulador para la siguiente iteración, y el acumulador final es lo que retorna array_reduce().

Úsala siempre que necesites colapsar un array entero en un único resultado y una sola llamada a array_sum(), array_filter() o array_map() no sea suficiente — por ejemplo, para sumar solo ciertos elementos, construir una tabla de búsqueda o encontrar un máximo con lógica personalizada. Esta guía cubre la sintaxis, el flujo del acumulador, los patrones más comunes y los errores frecuentes.

Sintaxis

array_reduce(array $array, callable $callback, mixed $initial = null): mixed

Parámetro	Descripción
`$array`	El array de entrada que se va a reducir.
`$callback`	Función llamada una vez por elemento. Recibe `($carry, $item)` y debe retornar el nuevo acumulador.
`$initial`	Valor inicial opcional para `$carry`. Por defecto es `null`.

La firma del callback es:

function (mixed $carry, mixed $item): mixed

$carry contiene el resultado acumulado hasta ahora — $initial en la primera llamada.
$item es el elemento actual del array.
El valor de retorno se convierte en $carry para el siguiente elemento. Olvidar el retorno es el error más común.

array_reduce() ignora las claves del array; solo los valores se pasan al callback. Si necesitas las claves, itera manualmente o usa array_keys() primero.

Casos de uso comunes

array_reduce() brilla siempre que muchos valores deban convertirse en uno. Los patrones más frecuentes incluyen:

Sumar o multiplicar elementos
Contar elementos que cumplen una condición
Construir un array asociativo (tabla de búsqueda) a partir de una lista
Aplanar o fusionar arrays anidados
Encontrar un mínimo o máximo con lógica de comparación personalizada

Ejemplo 1: Sumar los elementos de un array

El uso más sencillo es sumar números. El callback añade el elemento actual al total acumulado, y el 0 pasado como $initial hace que el total comience en cero.

php— editable, runs on the server

$carry mantiene el total acumulado, comenzando en 0, y $item es el número actual. Para una suma simple como esta también podrías usar la función integrada array_sum() — array_reduce() resulta útil cuando la acumulación necesita lógica personalizada (sumar solo números pares, multiplicar, etc.).

Ejemplo 2: Contar elementos de un array

Puedes contar elementos incrementando el acumulador en cada iteración en lugar de sumar el valor del elemento. Observa cómo $item no se usa aquí intencionalmente — array_reduce() no te obliga a usar el elemento actual.

php— editable, runs on the server

En este ejemplo, la variable $carry lleva la cuenta, comenzando en 0. La variable $item contiene el elemento actual que se procesa, pero no se usa en este caso.

Ejemplo 3: Construir un array asociativo (tabla de búsqueda)

Un patrón muy práctico es convertir una lista de registros en una tabla indexada por clave, de modo que puedas encontrar una entrada por nombre en lugar de buscar en toda la lista. El acumulador comienza como un array vacío y gana una clave por cada registro.

<?php

$data = array(
    array("name" => "John", "age" => 25),
    array("name" => "Jane", "age" => 30),
    array("name" => "Jim", "age" => 35)
);

$people = array_reduce($data, function($carry, $item) {
    $carry[$item["name"]] = $item["age"];
    return $carry;
}, array());

print_r($people);

?>

Pruébalo tú mismo »

El resultado es Array ( [John] => 25 [Jane] => 30 [Jim] => 35 ). Cada $item es el registro de una persona; el callback usa el nombre de la persona como clave y su edad como valor, retornando el array actualizado para que la siguiente iteración pueda añadir más entradas.

Ejemplo 4: Aplanar arrays anidados

Puedes aplanar un array de arrays en un único array plano fusionando cada subarray con el acumulador. Como array_merge() retorna un nuevo array, devolver su resultado hace que $carry crezca correctamente.

php— editable, runs on the server

Aquí la entrada es [[1, 2], [3, 4], [5]]. Cada $item es un array interno, y array_merge() añade sus valores a $carry, produciendo una única lista plana. (Esto solo aplana un nivel de profundidad.)

Ejemplo 5: Fusionar varios arrays en uno

La misma idea de fusión sirve para combinar una colección de arrays separados. Envuelve los arrays que quieras unir en un array externo y fusiona cada uno con el acumulador.

php— editable, runs on the server

$colors y $fruits se fusionan en orden, dando un único array combinado. Con muchos arrays esto es más limpio que encadenar varias llamadas a array_merge() manualmente.

Uso de funciones flecha

Desde PHP 7.4 puedes escribir el callback como una función flecha concisa. Captura variables externas automáticamente y retorna su expresión de forma implícita, lo que elimina el return que es fácil de olvidar:

<?php

$numbers = [1, 2, 3, 4, 5];
$sum = array_reduce($numbers, fn($carry, $item) => $carry + $item, 0);

echo $sum; // 15

?>

Errores frecuentes

Siempre retorna desde el callback. Si algún camino de ejecución olvida return $carry, el acumulador se convierte en null y todo lo que sigue falla. Las funciones flecha evitan este problema.
Atención al valor inicial. Sin $initial, $carry comienza como null. Para sumas numéricas pasa 0; para construir arrays pasa []. De lo contrario, el primer array_merge(null, …) o null + 1 producirá un comportamiento incorrecto o advertencias.
Los arrays vacíos retornan el valor inicial. array_reduce([], $fn, 0) retorna 0; sin valor inicial retorna null. Maneja ese caso si una entrada vacía es posible.
Las claves se ignoran. Solo los valores llegan al callback. Reduce sobre array_keys($arr) si las necesitas.

Este ejemplo encuentra el máximo sin un valor inicial, tratando el primer elemento de forma especial:

<?php

$numbers = [10, 5, 20, 8];
$max = array_reduce($numbers, function ($carry, $item) {
    return ($carry === null || $item > $carry) ? $item : $carry;
});

echo $max; // 20

?>

Funciones relacionadas

array_map() — transforma cada elemento en un nuevo array (uno a uno), en lugar de reducirlos a un único valor.
array_filter() — conserva solo los elementos que superan una prueba.
array_sum() — un atajo para el caso de suma simple.
array_merge() — une arrays directamente cuando no se necesita lógica por elemento.

Conclusión

array_reduce() reduce un array a un único valor pasando un acumulador a través de un callback. Una vez que interiorices el flujo ($carry, $item) => newCarry, podrás sumar, contar, construir tablas de búsqueda, aplanar y fusionar con la misma herramienta compacta. Recuerda las dos reglas que previenen la mayoría de los errores: siempre retorna el nuevo acumulador y elige un valor $initial que coincida con el tipo que estás construyendo.

Práctica

¿Qué hace la función array_reduce() en PHP?

La función array_reduce() envía cada valor de un array a una función, acumulando el resultado.La función array_reduce() ordena un array en orden ascendente.La función array_reduce() crea un nuevo array con los elementos en orden inverso.La función array_reduce() reduce iterativamente el array a un único valor usando una función de callback.