PHP array_merge() : fusionner deux tableaux ou plus

array_merge($a, $b) renvoie un nouveau tableau avec les éléments de $a suivis de ceux de $b. Les clés numériques sont renumérotées depuis 0 ; quand les deux tableaux ont la même clé de type chaîne, la valeur du dernier tableau l'emporte. Passez autant de tableaux que vous voulez.

<?php
$fruits = ['apple', 'pear'];
$veg    = ['carrot', 'leek'];
print_r(array_merge($fruits, $veg));

$defaults = ['color' => 'blue', 'size' => 'M'];
$chosen   = ['size' => 'L'];
print_r(array_merge($defaults, $chosen));   // later value wins

array_merge() ne modifie pas ses arguments. Elle renvoie le tableau combiné, donc affectez le résultat : $all = array_merge($all, $more);.

Les clés numériques sont renumérotées

array_merge() traite les clés entières comme des positions, pas comme des noms. Chaque élément à clé entière est ajouté à la suite et reçoit une nouvelle clé depuis 0, même si les tableaux utilisaient les mêmes nombres ou avaient des trous. C'est ce que vous voulez pour des listes, et une surprise quand les nombres sont des identifiants.

<?php
$a = [5 => 'Ada', 9 => 'Linus'];
$b = [5 => 'Grace'];

print_r(array_merge($a, $b));   // keys 0, 1, 2: the IDs are gone

$usersById = [101 => 'Ada', 102 => 'Linus'];
$more      = [103 => 'Grace'];
print_r($usersById + $more);    // + keeps the integer keys

Les clés de type chaîne qui ressemblent à des entiers ('101') sont stockées comme des entiers, elles sont donc aussi renumérotées. Des clés comme 'id101' restent telles quelles.

array_merge ou l'opérateur +

L'opérateur + (union de tableaux) combine aussi des tableaux, mais avec la règle inverse : pour toute clé qui existe déjà dans le tableau de gauche, la valeur de gauche l'emporte et celle de droite est abandonnée. Il ne renumérote jamais. Cela fait de + la façon naturelle de compléter avec des valeurs par défaut, et d'array_merge() la façon naturelle de les écraser.

<?php
$defaults = ['theme' => 'light', 'lang' => 'en', 'per_page' => 20];
$user     = ['theme' => 'dark'];

print_r(array_merge($defaults, $user));   // user overrides defaults
print_r($user + $defaults);               // same result: user is on the left

// With lists, + compares positions and drops duplicates by key
print_r(['a', 'b'] + ['x', 'y', 'z']);

Le dernier exemple du bloc est le piège classique de + : ['a', 'b'] + ['x', 'y', 'z'] donne a, b, z, car les clés 0 et 1 existent déjà à gauche.

Syntaxe de décomposition : [...$a, ...$b]

L'opérateur de décomposition déballe des tableaux dans un littéral de tableau. Il se comporte comme array_merge() : les clés entières sont renumérotées et, depuis PHP 8.1, les clés de type chaîne sont permises et la dernière l'emporte. Il se lit bien quand vous mélangez des tableaux et des valeurs isolées.

<?php
$first  = [1, 2];
$second = [3, 4];

print_r([...$first, ...$second, 5]);

$base  = ['host' => 'localhost', 'port' => 3306];
$local = ['port' => 3307];
print_r([...$base, ...$local]);

Pour ajouter un tableau à un tableau existant sur place, voir array_push() avec l'opérateur de décomposition.

Fusionner un tableau de tableaux

Quand les tableaux à combiner sont eux-mêmes dans une liste, décomposez cette liste dans array_merge(). C'est aussi la façon rapide de fusionner dans une boucle : rassemblez les morceaux, puis fusionnez une fois.

<?php
$pages = [
    ['ada', 'linus'],
    ['grace'],
    ['margaret', 'alan'],
];

$all = array_merge(...$pages);
print_r($all);

$batches = [];
for ($page = 1; $page <= 3; $page++) {
    $batches[] = range($page * 10, $page * 10 + 2);   // pretend API page
}
echo implode(', ', array_merge(...$batches)), "\n";

var_dump(array_merge(...[]));   // an empty list gives []

Écrire $all = array_merge($all, $batch); dans la boucle fonctionne, mais copie tout le tableau grandissant à chaque passage, ce qui devient lent avec des milliers d'éléments.

array_merge_recursive et array_replace

array_merge_recursive() fusionne aussi les tableaux imbriqués, mais pour une clé de type chaîne en double contenant des valeurs simples, elle n'écrase pas : elle rassemble les deux valeurs dans un nouveau tableau. C'est rarement ce qu'on veut pour une configuration. array_replace_recursive() est généralement le bon outil dans ce cas : elle écrase les valeurs à chaque niveau et garde les clés.

<?php
$defaults = ['db' => ['host' => 'localhost', 'port' => 3306], 'debug' => false];
$override = ['db' => ['port' => 3307], 'debug' => true];

echo json_encode(array_merge($defaults, $override)), "\n";
echo json_encode(array_merge_recursive($defaults, $override)), "\n";
echo json_encode(array_replace_recursive($defaults, $override)), "\n";

print_r(array_replace([5 => 'a', 9 => 'b'], [9 => 'B']));   // keeps integer keys

Lisez les trois lignes JSON de haut en bas : array_merge() a remplacé tout le tableau db et perdu host, array_merge_recursive() a transformé port et debug en listes de deux éléments, et array_replace_recursive() a produit la configuration voulue.

Erreur fréquente : fusionner ne supprime rien

array_merge() garde les valeurs en double rangées sous des clés différentes. Fusionner deux listes de tags vous donne deux fois chaque tag commun. Passez le résultat dans array_unique() puis array_values() pour le renuméroter.

<?php
$postTags  = ['php', 'arrays', 'beginner'];
$extraTags = ['arrays', 'tutorial', 'php'];

$merged = array_merge($postTags, $extraTags);
echo implode(', ', $merged), "\n";

$unique = array_values(array_unique($merged));
echo implode(', ', $unique), "\n";

La page array_unique explique comment supprimer les doublons dans des lignes et des tableaux imbriqués.