PHP Array Merge : Guide approfondi

La fonction PHP array_merge() combine deux tableaux ou plus en un seul tableau. Elle prend un ou plusieurs tableaux en arguments et retourne un nouveau tableau ; les tableaux d'origine restent inchangés. Ce guide explique comment array_merge() gère les clés string, les clés numériques et les tableaux imbriqués, les pièges à éviter, et en quoi elle diffère de l'opérateur d'union +.

Les deux règles qui expliquent presque tous les résultats sont :

• Les clés string présentes dans plusieurs tableaux sont écrasées — la valeur du tableau le plus à droite l'emporte.
• Les clés numériques ne sont jamais écrasées. Chaque valeur est ajoutée et les clés sont réindexées séquentiellement à partir de 0.

Remarque : Depuis PHP 8.0, passer un argument non-tableau à array_merge() lève une TypeError. (En PHP 7, cela émettait un avertissement et retournait null.) Appeler array_merge() sans argument retourne un tableau vide.

Utilisation de base de array_merge()

L'utilisation de base de la fonction array_merge() est simple. Il suffit de passer deux tableaux ou plus en arguments, et la fonction retournera un nouveau tableau résultant de leur fusion. Voici un exemple :

Exemple de la fonction array_merge en PHP

Résultat :

Array
(
    [color] => green
    [0] => 2
    [1] => 4
    [2] => a
    [3] => b
    [shape] => rectangle
    [4] => 4
)

Deux points sont à noter dans ce résultat :

• La clé string color est présente dans les deux tableaux, donc la valeur de $array2 (green) a écrasé celle de $array1 (red).
• Les clés numériques n'ont pas été conservées. Les valeurs originales 2 et 4 de $array1 ainsi que le 4 de $array2 ont toutes été conservées (aucune n'a été écrasée) et renumérotées 0, 1, 4.

Réindexation des clés numériques

Comme les clés numériques sont renumérotées, vous ne pouvez pas compter sur la survie des clés entières d'origine après une fusion. Appeler array_merge() sur un seul tableau est même une méthode courante et rapide pour le réindexer :

<?php

$nums = [10 => "a", 25 => "b", 7 => "c"];
$result = array_merge($nums);
print_r($result);

?>

Résultat :

Array
(
    [0] => a
    [1] => b
    [2] => c
)

Si vous avez besoin de conserver des clés entières spécifiques, utilisez plutôt l'opérateur d'union + ou array_replace().

Fusionner des tableaux multidimensionnels

La fonction array_merge() peut également être utilisée pour fusionner des tableaux multidimensionnels. Pour ce faire, il suffit de passer chaque tableau en argument de la fonction. Voici un exemple :

PHP : fusionner des tableaux multidimensionnels avec array_merge_recursive

Résultat :

Array
(
    [color] => Array
        (
            [favorite] => green
        )
    [0] => 2
    [1] => 4
    [2] => a
    [3] => b
    [shape] => rectangle
    [4] => 4
)

Notez que array_merge() ne fusionne pas les tableaux imbriqués. Lorsque deux tableaux partagent une clé string dont la valeur est elle-même un tableau, la valeur imbriquée du tableau le plus à droite remplace entièrement celle du précédent — ici ["favorite" => "green"] a simplement écrasé ["favorite" => "red"]. Pour fusionner les tableaux imbriqués de façon récursive plutôt que de les écraser, utilisez array_merge_recursive().

array_merge() vs l'opérateur d'union

PHP propose également l'opérateur d'union + pour combiner des tableaux, mais son comportement est très différent de array_merge(). L'opérateur d'union conserve la valeur de l'opérande de gauche en cas de collision de clés, et ne réindexe jamais les clés numériques.

<?php

$array1 = ["a", "b", "c"];
$array2 = ["x", "y", "z", "w"];

print_r(array_merge($array1, $array2)); // appends + reindexes
print_r($array1 + $array2);             // keeps left, no reindex

?>

Résultat :

Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => x
    [4] => y
    [5] => z
    [6] => w
)
Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => w
)

Avec array_merge(), chaque élément est conservé et renuméroté. Avec +, les index 0–2 existaient déjà dans $array1 et l'emportent ; seul l'index 3 (w) est repris de $array2. Utilisez + lorsque vous souhaitez combler les clés manquantes (par exemple fusionner des options utilisateur sur des valeurs par défaut) tout en préservant les valeurs existantes et les clés entières ; utilisez array_merge() lorsque vous voulez une liste plate indexée séquentiellement. Voir les opérateurs PHP pour en savoir plus.

Fusion d'un tableau indexé avec un tableau associatif

Lors de la fusion d'un tableau indexé avec un tableau associatif, les valeurs des deux tableaux sont combinées. Voici un exemple :

PHP : exemple de fusion d'un tableau indexé avec un tableau associatif via array_merge

Résultat :

Array
(
    [0] => a
    [1] => b
    [2] => c
    [a] => apple
    [b] => banana
    [c] => cherry
)

Comme vous pouvez le voir, les valeurs des deux tableaux sont combinées. Comme les clés sont de types différents (numériques et string), aucun écrasement n'a lieu. C'est un détail important à garder à l'esprit lors de la fusion de tableaux avec des types de clés différents.

Fusion d'un tableau associatif avec un tableau indexé

Le résultat de la fusion d'un tableau associatif avec un tableau indexé est similaire. Les valeurs sont combinées et les clés sont conservées selon leur type. Voici un exemple :

PHP : fusion d'un tableau associatif avec un tableau indexé via array_merge

Résultat :

Array
(
    [a] => apple
    [b] => banana
    [c] => cherry
    [0] => a
    [1] => b
    [2] => c
)

Comme illustré, les valeurs se combinent sans conflit. Les clés string de $array1 sont conservées, tandis que les clés numériques de $array2 sont réindexées à partir de 0.

Considérations de performance

La fonction array_merge() a une complexité temporelle linéaire, ce qui signifie que le temps nécessaire à la fusion des tableaux augmente linéairement avec leur taille. C'est pourquoi il est important de limiter le nombre de tableaux à fusionner et d'éviter d'utiliser cette fonction sur des tableaux extrêmement volumineux.

Conclusion

La fonction array_merge() est un outil polyvalent pour combiner des tableaux en PHP. Retenez les deux règles fondamentales : les clés string sont écrasées par les tableaux suivants, tandis que les clés numériques sont ajoutées et réindexées à partir de 0. Lorsque ces comportements par défaut ne conviennent pas, choisissez plutôt une fonction connexe :

• array_merge_recursive() — fusionne les tableaux imbriqués au lieu de les écraser.
• array_replace() — remplace les valeurs par clé tout en préservant les clés numériques.
• L'opérateur d'union + — conserve les valeurs de gauche et ne réindexe jamais.
• array_combine() — construit un tableau à partir d'un tableau de clés et d'un tableau de valeurs séparés.

Pratique