Fonction PHP array_reduce : Guide Complet

array_reduce() parcourt un tableau élément par élément et le réduit à une valeur unique — une somme, un comptage, l'élément le plus grand, une structure reconstruite, etc. À chaque itération, elle passe deux arguments à votre callback : le résultat accumulé jusqu'à présent (l'accumulateur, conventionnellement nommé $carry) et l'élément courant ($item). Ce que le callback retourne devient le nouvel accumulateur pour l'itération suivante, et l'accumulateur final est ce que retourne array_reduce().

Utilisez-la chaque fois que vous devez réduire un tableau entier à un seul résultat et qu'un simple appel à array_sum(), array_filter() ou array_map() ne suffit pas — par exemple pour sommer uniquement certains éléments, construire une table de correspondance, ou trouver un maximum avec une logique personnalisée. Ce guide couvre la syntaxe, le flux de l'accumulateur, les patterns courants et les pièges à éviter.

Syntaxe

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

La signature du callback est :

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

• $carry contient le résultat accumulé jusqu'à présent — $initial lors du premier appel.
• $item est l'élément courant du tableau.
• La valeur de retour devient $carry pour l'élément suivant. Oublier de retourner est le bug le plus fréquent.

array_reduce() ignore les clés du tableau ; seules les valeurs sont passées au callback. Si vous avez besoin des clés, parcourez manuellement ou utilisez array_keys() au préalable.

Cas d'utilisation courants

array_reduce() excelle chaque fois que de nombreuses valeurs doivent en devenir une. Les patterns courants incluent :

• Sommer ou multiplier des éléments
• Compter les éléments qui satisfont une condition
• Construire un tableau associatif (table de correspondance) à partir d'une liste
• Aplatir ou fusionner des tableaux imbriqués
• Trouver un minimum ou un maximum avec une logique de comparaison personnalisée

Exemple 1 : Sommer les éléments d'un tableau

L'utilisation la plus simple consiste à additionner des nombres. Le callback ajoute l'élément courant au total en cours, et le 0 passé comme $initial fait démarrer le total à zéro.

$carry maintient le total en cours, en démarrant à 0, et $item est le nombre courant. Pour une simple somme comme celle-ci, vous pourriez également utiliser la fonction intégrée array_sum() — array_reduce() devient utile lorsque l'accumulation nécessite une logique personnalisée (sommer uniquement les nombres pairs, multiplier, etc.).

Exemple 2 : Compter les éléments d'un tableau

Vous pouvez compter les éléments en incrémentant l'accumulateur à chaque itération plutôt qu'en ajoutant la valeur de l'élément. Notez que $item est intentionnellement inutilisé ici — array_reduce() ne vous oblige pas à utiliser l'élément courant.

Dans cet exemple, la variable $carry garde la trace du comptage, en démarrant à 0. La variable $item contient l'élément courant en cours de traitement, mais n'est pas utilisée dans ce cas.

Exemple 3 : Construire un tableau associatif (table de correspondance)

Un pattern très pratique consiste à transformer une liste d'enregistrements en une table indexée afin de pouvoir retrouver une entrée par son nom plutôt que de parcourir toute la liste. L'accumulateur démarre comme un tableau vide et reçoit une clé supplémentaire par enregistrement.

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

?>

Le résultat est Array ( [John] => 25 [Jane] => 30 [Jim] => 35 ). Chaque $item est un enregistrement de personne ; le callback utilise le nom de la personne comme clé et son âge comme valeur, retournant le tableau mis à jour pour que l'itération suivante puisse y ajouter des données.

Exemple 4 : Aplatir des tableaux imbriqués

Vous pouvez aplatir un tableau de tableaux en un seul tableau plat en fusionnant chaque sous-tableau dans l'accumulateur. Puisque array_merge() retourne un nouveau tableau, retourner son résultat permet à $carry de grandir correctement.

Ici l'entrée est [[1, 2], [3, 4], [5]]. Chaque $item est un tableau interne, et array_merge() ajoute ses valeurs à $carry, produisant une liste plate unique. (Cela n'aplatit qu'un seul niveau de profondeur.)

Exemple 5 : Fusionner plusieurs tableaux en un seul

La même idée de fusion fonctionne pour combiner une collection de tableaux distincts. Enveloppez les tableaux que vous souhaitez joindre dans un tableau extérieur et fusionnez chacun dans l'accumulateur.

$colors et $fruits sont fusionnés dans l'ordre, donnant un seul tableau combiné. Avec de nombreux tableaux, c'est plus propre que d'enchaîner plusieurs appels à array_merge() à la main.

Utilisation des fonctions fléchées

Depuis PHP 7.4, vous pouvez écrire le callback sous la forme d'une fonction fléchée concise. Elle capture automatiquement les variables extérieures et retourne implicitement son expression, ce qui élimine le return facile à oublier :

<?php

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

echo $sum; // 15

?>

Pièges courants

• Toujours retourner depuis le callback. Si un chemin de code oublie de return $carry, l'accumulateur devient null et tout ce qui suit se brise. Les fonctions fléchées évitent ce problème.
• Faites attention à la valeur initiale. Sans $initial, $carry démarre à null. Pour les sommes numériques, passez 0 ; pour la construction de tableaux, passez []. Sinon, le premier array_merge(null, …) ou null + 1 se comportera mal ou générera un avertissement.
• Les tableaux vides retournent la valeur initiale. array_reduce([], $fn, 0) retourne 0 ; sans valeur initiale, il retourne null. Gérez ce cas si une entrée vide est possible.
• Les clés sont ignorées. Seules les valeurs parviennent au callback. Réduisez sur array_keys($arr) si vous en avez besoin.

Cet exemple trouve le maximum sans valeur initiale, en traitant le premier élément spécialement :

<?php

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

echo $max; // 20

?>

Fonctions connexes

• array_map() — transforme chaque élément en un nouveau tableau (un-à-un), au lieu de les réduire à une valeur unique.
• array_filter() — conserve uniquement les éléments qui passent un test.
• array_sum() — un raccourci pour le cas de somme simple.
• array_merge() — joint des tableaux directement sans logique par élément.

Conclusion

array_reduce() réduit un tableau à une valeur unique en faisant passer un accumulateur à travers un callback. Une fois le flux ($carry, $item) => newCarry bien intériorisé, vous pouvez sommer, compter, construire des tables de correspondance, aplatir et fusionner avec le même outil compact. Souvenez-vous des deux règles qui préviennent la plupart des bugs : toujours retourner le nouvel accumulateur, et choisir une valeur $initial qui correspond au type que vous construisez.

Pratique