PHP array_merge(): Merge Two or More Arrays

array_merge($a, $b) returns a new array with the elements of $a followed by the elements of $b. Numeric keys are renumbered from 0; when both arrays have the same string key, the value from the later array wins. Pass as many arrays as you like.

<?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() does not change its arguments. It returns the combined array, so assign the result: $all = array_merge($all, $more);.

Numeric keys are renumbered

array_merge() treats integer keys as positions, not as names. Every element with an integer key is appended and gets a fresh key from 0, even if the arrays used the same numbers or gaps. That is what you want for lists, and a surprise when the numbers are IDs.

<?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 keys that look like integers ('101') are stored as integers, so they are renumbered too. Keys like 'id101' stay as they are.

array_merge vs the + operator

The + operator (array union) also combines arrays, but with the opposite rule: for any key that already exists in the left array, the left value wins and the right one is dropped. It never renumbers. This makes + the natural way to fill in defaults, and array_merge() the natural way to override them.

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

The last example in the block is the classic + trap: ['a', 'b'] + ['x', 'y', 'z'] gives a, b, z, because keys 0 and 1 already exist on the left.

Spread syntax: [...$a, ...$b]

The spread operator unpacks arrays inside an array literal. It behaves like array_merge(): integer keys are renumbered and, since PHP 8.1, string keys are allowed and the later one wins. It reads well when you mix arrays with single values.

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

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

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

To append an array to an existing one in place, see array_push() with the spread operator.

Merge an array of arrays

When the arrays to combine are themselves in a list, spread that list into array_merge(). This is also the fast way to merge inside a loop: collect the pieces, then merge once.

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

Writing $all = array_merge($all, $batch); inside the loop works, but it copies the whole growing array on every pass, which gets slow with thousands of items.

array_merge_recursive and array_replace

array_merge_recursive() merges nested arrays too, but for a duplicate string key holding plain values it does not overwrite: it collects both values into a new array. That is rarely what you want for configuration. array_replace_recursive() is usually the right tool there: it overwrites values at every level and keeps keys.

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

Read the three JSON lines from top to bottom: array_merge() replaced the whole db array and lost host, array_merge_recursive() turned port and debug into two-element lists, and array_replace_recursive() produced the config you meant.

Common mistake: merging removes nothing

array_merge() keeps duplicate values that sit under different keys. Merging two lists of tags gives you each shared tag twice. Pass the result through array_unique() and then array_values() to renumber it.

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

The array_unique page covers removing duplicates from rows and nested arrays.