Funzione array_reduce() di PHP: La Guida Completa

array_reduce() scorre un array un elemento alla volta e lo riduce a un singolo valore — una somma, un conteggio, l'elemento più grande, una struttura ricostruita e così via. Ad ogni iterazione passa due argomenti alla callback: il risultato accumulato finora (l'accumulatore, convenzionalmente chiamato $carry) e l'elemento corrente ($item). Qualunque cosa la callback restituisca diventa il nuovo accumulatore per l'iterazione successiva, e l'accumulatore finale è ciò che array_reduce() ritorna.

Usala ogni volta che devi ridurre un intero array a un unico risultato e una singola chiamata a array_sum(), array_filter() o array_map() non è sufficiente — per esempio sommando solo determinati elementi, costruendo una tabella di ricerca o trovando un massimo con logica personalizzata. Questa guida copre la sintassi, il flusso dell'accumulatore, i pattern comuni e le insidie più frequenti.

Sintassi

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

La firma della callback è:

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

• $carry contiene il risultato accumulato finora — $initial alla prima chiamata.
• $item è l'elemento corrente dell'array.
• Il valore restituito diventa $carry per l'elemento successivo. Dimenticare il return è il bug più comune.

array_reduce() ignora le chiavi dell'array; alla callback vengono passati solo i valori. Se hai bisogno delle chiavi, itera manualmente oppure usa prima array_keys().

Casi d'uso comuni

array_reduce() eccelle ogni volta che molti valori devono diventare uno. I pattern più comuni includono:

• Sommare o moltiplicare elementi
• Contare elementi che soddisfano una condizione
• Costruire un array associativo (tabella di ricerca) da una lista
• Appiattire o unire array annidati
• Trovare un minimo o un massimo con logica di confronto personalizzata

Esempio 1: Sommare gli elementi di un array

L'uso più semplice consiste nell'addizionare numeri. La callback aggiunge l'elemento corrente al totale progressivo, e il valore 0 passato come $initial fa partire il totale da zero.

$carry mantiene il totale progressivo, partendo da 0, e $item è il numero corrente. Per una semplice somma come questa potresti anche usare la funzione integrata array_sum() — array_reduce() diventa utile quando l'accumulazione richiede logica personalizzata (sommare solo i numeri pari, moltiplicare, ecc.).

Esempio 2: Contare gli elementi di un array

Puoi contare gli elementi incrementando l'accumulatore a ogni iterazione anziché aggiungere il valore dell'elemento. Nota come $item sia volutamente inutilizzato qui — array_reduce() non ti obbliga a usare l'elemento corrente.

In questo esempio, la variabile $carry tiene traccia del conteggio, partendo da 0. La variabile $item contiene l'elemento corrente in elaborazione, ma in questo caso non viene utilizzata.

Esempio 3: Costruire un array associativo (tabella di ricerca)

Un pattern molto pratico consiste nel trasformare una lista di record in una struttura indicizzata per chiave, in modo da trovare una voce per nome invece di cercare nell'intera lista. L'accumulatore parte come array vuoto e acquisisce una chiave per ogni record.

<?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);

?>

Il risultato è Array ( [John] => 25 [Jane] => 30 [Jim] => 35 ). Ogni $item è il record di una persona; la callback usa il nome della persona come chiave e la sua età come valore, restituendo l'array aggiornato in modo che l'iterazione successiva possa aggiungervi dati.

Esempio 4: Appiattire array annidati

Puoi appiattire un array di array in un unico array piatto unendo ogni sotto-array all'accumulatore. Poiché array_merge() restituisce un nuovo array, restituirne il risultato mantiene $carry in crescita correttamente.

Qui l'input è [[1, 2], [3, 4], [5]]. Ogni $item è un array interno e array_merge() aggiunge i suoi valori a $carry, producendo una singola lista piatta. (Questo appiattisce solo un livello.)

Esempio 5: Unire più array in uno

La stessa idea di unione funziona per combinare una raccolta di array separati. Racchiudi gli array da unire in un array esterno e unisci ognuno all'accumulatore.

$colors e $fruits vengono uniti in ordine, producendo un unico array combinato. Con molti array questo approccio è più pulito che concatenare a mano più chiamate a array_merge().

Uso delle arrow function

Da PHP 7.4 puoi scrivere la callback come una concisa arrow function. Cattura automaticamente le variabili esterne e restituisce implicitamente la propria espressione, eliminando il return facile da dimenticare:

<?php

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

echo $sum; // 15

?>

Insidie comuni

• Restituisci sempre dalla callback. Se un ramo del codice dimentica di fare return $carry, l'accumulatore diventa null e tutto ciò che segue si rompe. Le arrow function evitano questo problema.
• Attenzione al valore iniziale. Senza $initial, $carry parte come null. Per somme numeriche passa 0; per la costruzione di array passa []. Altrimenti il primo array_merge(null, …) o null + 1 si comporterà male o genererà un avviso.
• Gli array vuoti restituiscono il valore iniziale. array_reduce([], $fn, 0) restituisce 0; senza valore iniziale restituisce null. Gestisci questo caso se un input vuoto è possibile.
• Le chiavi vengono ignorate. Alla callback arrivano solo i valori. Riduci su array_keys($arr) se ne hai bisogno.

Questo esempio trova il massimo senza un valore iniziale, trattando il primo elemento in modo speciale:

<?php

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

echo $max; // 20

?>

Funzioni correlate

• array_map() — trasforma ogni elemento in un nuovo array (uno-a-uno), invece di ridurlo a un unico valore.
• array_filter() — mantiene solo gli elementi che superano un test.
• array_sum() — una scorciatoia per il caso di semplice somma.
• array_merge() — unisce array direttamente quando non è necessaria logica per-elemento.

Conclusione

array_reduce() riduce un array a un singolo valore facendo scorrere un accumulatore attraverso una callback. Una volta interiorizzato il flusso ($carry, $item) => newCarry, puoi sommare, contare, costruire tabelle di ricerca, appiattire e unire con lo stesso strumento compatto. Ricorda le due regole che prevengono la maggior parte dei bug: restituisci sempre il nuovo accumulatore e scegli un valore $initial che corrisponda al tipo che stai costruendo.

Pratica