PHP array_merge(): zwei oder mehr Arrays zusammenführen

array_merge($a, $b) liefert ein neues Array mit den Elementen von $a, gefolgt von den Elementen von $b. Numerische Schlüssel werden ab 0 neu nummeriert; haben beide Arrays denselben String-Schlüssel, gewinnt der Wert aus dem späteren Array. Du kannst beliebig viele Arrays übergeben.

<?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() ändert seine Argumente nicht. Es liefert das kombinierte Array, also weist du das Ergebnis zu: $all = array_merge($all, $more);.

Numerische Schlüssel werden neu nummeriert

array_merge() behandelt Ganzzahl-Schlüssel als Positionen, nicht als Namen. Jedes Element mit Ganzzahl-Schlüssel wird angehängt und bekommt einen frischen Schlüssel ab 0, auch wenn die Arrays dieselben Zahlen oder Lücken verwendet haben. Bei Listen ist das genau richtig, bei Zahlen, die IDs sind, eine Überraschung.

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

String-Schlüssel, die wie Ganzzahlen aussehen ('101'), werden als Ganzzahlen gespeichert und daher ebenfalls neu nummeriert. Schlüssel wie 'id101' bleiben, wie sie sind.

array_merge vs der Operator +

Der Operator + (Array-Vereinigung) kombiniert ebenfalls Arrays, aber mit der umgekehrten Regel: Bei jedem Schlüssel, der im linken Array schon existiert, gewinnt der linke Wert, und der rechte wird verworfen. Er nummeriert nie neu. Damit ist + der natürliche Weg, Standardwerte aufzufüllen, und array_merge() der natürliche Weg, sie zu überschreiben.

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

Das letzte Beispiel im Block ist die klassische Falle mit +: ['a', 'b'] + ['x', 'y', 'z'] ergibt a, b, z, weil die Schlüssel 0 und 1 links schon existieren.

Spread-Syntax: [...$a, ...$b]

Der Spread-Operator entpackt Arrays in einem Array-Literal. Er verhält sich wie array_merge(): Ganzzahl-Schlüssel werden neu nummeriert, und seit PHP 8.1 sind String-Schlüssel erlaubt, wobei der spätere gewinnt. Er liest sich gut, wenn du Arrays mit einzelnen Werten mischst.

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

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

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

Um ein Array direkt an ein bestehendes anzuhängen, siehe array_push() mit dem Spread-Operator.

Ein Array von Arrays zusammenführen

Wenn die zu kombinierenden Arrays selbst in einer Liste stehen, spreadest du diese Liste in array_merge(). Das ist auch der schnelle Weg, in einer Schleife zusammenzuführen: Teile sammeln, dann einmal zusammenführen.

<?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 []

$all = array_merge($all, $batch); in der Schleife funktioniert, kopiert aber bei jedem Durchlauf das ganze wachsende Array, was bei Tausenden Einträgen langsam wird.

array_merge_recursive und array_replace

array_merge_recursive() führt auch verschachtelte Arrays zusammen, überschreibt aber bei einem doppelten String-Schlüssel mit einfachen Werten nicht: Es sammelt beide Werte in einem neuen Array. Für Konfigurationen ist das selten gewollt. Dort ist meist array_replace_recursive() das richtige Werkzeug: Es überschreibt Werte auf jeder Ebene und behält die Schlüssel.

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

Lies die drei JSON-Zeilen von oben nach unten: array_merge() hat das ganze Array db ersetzt und host verloren, array_merge_recursive() hat port und debug in Listen mit zwei Elementen verwandelt, und array_replace_recursive() hat die Konfiguration erzeugt, die du gemeint hast.

Typischer Fehler: Zusammenführen entfernt nichts

array_merge() behält doppelte Werte, die unter verschiedenen Schlüsseln stehen. Zwei Tag-Listen zusammenzuführen gibt dir jeden gemeinsamen Tag zweimal. Schick das Ergebnis durch array_unique() und dann durch array_values(), um neu zu nummerieren.

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

Die Seite zu array_unique behandelt das Entfernen von Duplikaten aus Zeilen und verschachtelten Arrays.