What's the difference between array_merge and array + array?

Question

A fairly simple question. What's the difference between:

$merged = array_merge($array1, $array2);

and

$merged = $array1 + $array2;

?

Answer 1

Here's a simple illustrative test:

$ar1 = [
   0  => '1-0',
  'a' => '1-a',
  'b' => '1-b'
];


$ar2 = [
   0  => '2-0',
   1  => '2-1',
  'b' => '2-b',
  'c' => '2-c'
];

print_r($ar1+$ar2);

print_r(array_merge($ar1,$ar2));

with the result:

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

Notice that duplicate non-numeric keys will take the first value using the union operator but the later one using the array_merge.

For numeric keys, the first value will be used with the union operator whereas the all the values will be used with the array_merge, just reindexed.

I generally use union operator for associative arrays and array_merge for numeric. Of course, you can just as well use the array_merge for associative, just that the later values overwrite earlier ones.

Answer 2

The difference is:

The + operator takes the union of the two arrays, whereas the array_merge function takes the union BUT the duplicate keys are overwritten.

Answer 3

Source: https://softonsofa.com/php-array_merge-vs-array_replace-vs-plus-aka-union/

Stop using array_merge($defaults, $options):

function foo(array $options)
{
   $options += ['foo' => 'bar'];

   // ...
}

Note: array_replace function exists since PHP5.3.

Answer 4

array_merge() causes all numeric keys found in the input arrays to be reindexed in the resultant array. The union operator + does not cause a reindex.

Answer 5

The + sign only takes the value from the first occurence of an array key.
array_merge takes the value from the last occurrence of an array key.

Example:

    $first = ['a'=>'one',
            'b'=>'two',
            'c'=>'three'];
                    
    $second = ['a'=>'fourth',
            'b'=>'fifth',
            'c'=>'sixth',
            '3'=>'number three'];
                    
    $merged = $first + $second;
    echo "<pre> plus sign merge\n";
    var_dump($merged);
    
    $merged = array_merge($first,$second);
    echo "\n array_merge function merge\n";
    var_dump($merged);

This outputs:

plus sign merge
array(4) {
["a"]=>
string(3) "one"
["b"]=>
string(3) "two"
["c"]=>
string(5) "three"
[3]=>
string(12) "number three"
}

array_merge function merge
array(4) {
["a"]=>
string(6) "fourth"
["b"]=>
string(5) "fifth"
["c"]=>
string(5) "sixth"
[0]=>
string(12) "number three"
}

Interesting to note in this is that the array_merge actally erases the '3' index of number three even though it's a string, because it's a number.

So take care when merging with array_merge arrays with numerical indexes. They might lose their keys. if they are important to you precede them with a string.

Instead of '3' => 'three' use something like '_3' => 'three'

---

Also if you use numerical indexes it's important to note that if you add two array, it only looks at the numerical index and takes the value from the "first" array that has an array key with that value.

Array merge will merge the arrays together, ignoring similar keys and values.

So depending on the "type" of array indexes, numerical or string, the results will vary.

$arr = ['foo', 'bar', 'baz'];
$arr2 = ['xfoo', 'xbar', 'baz'];
$arr3 = $arr2 + $arr;
$arr4 = array_merge($arr, $arr2);
var_dump($arr3);

which gives the output:

array(3) {
  [0]=>
  string(4) "xfoo"
  [1]=>
  string(4) "xbar"
  [2]=>
  string(3) "baz"
}
array(6) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(3) "baz"
  [3]=>
  string(4) "xfoo"
  [4]=>
  string(4) "xbar"
  [5]=>
  string(3) "baz"
}

var_dump($arr4);

Answer 6

I believe array_merge overwrites duplicate non_numeric keys while $array1 + $array2 does not.

Answer 7

Yet another example (arrays without explicit keys; it's obvious regarding to how the operator + and array_merge work, but "obvious" things are simpler when seen ;))

$a = array('apple');
$b = array('orange', 'lemon');

echo '$a + $b = ';             print_r($a + $b);
echo 'array_merge($a, $b) = '; print_r(array_merge($a, $b));

will give:

$a + $b = Array
(
    [0] => apple
    [1] => lemon
)
array_merge($a, $b) = Array
(
    [0] => apple
    [1] => orange
    [2] => lemon
)

Answer 8

Please pay attention for another difference: the union (+) won't overwrite non-empty value with empty value (considering a same key), whereas array_merge will:

$a = array('foo' => 'bar');
$b = array('foo' => ''); // or false or 0

print_r($a+$b);
print_r(array_merge($a, $b);

Outputs :

Array
(
    [foo] => bar
)
Array
(
    [foo] => 0
)

Answer 9

So apparently if you change the order both union and merge will do the same thing

$a = array('foo' => 'bar', 'x' => 'fromA');
$b = array('foo' => null, 'x' => 'fromB');

echo '$a+$b: ';
var_dump($a+$b);

echo '$b+$a: ';
var_dump($b+$a);

echo 'array_merge($a, $b): ';
var_dump(array_merge($a, $b));

echo 'array_merge($b, $a): ';
var_dump(array_merge($b, $a));

Outputs :

$a+$b: array(2) {
  ["foo"]=>
  string(3) "bar"
  ["x"]=>
  string(5) "fromA"
}
$b+$a: array(2) {
  ["foo"]=>
  NULL
  ["x"]=>
  string(5) "fromB"
}
array_merge($a, $b): array(2) {
  ["foo"]=>
  NULL
  ["x"]=>
  string(5) "fromB"
}
array_merge($b, $a): array(2) {
  ["foo"]=>
  string(3) "bar"
  ["x"]=>
  string(5) "fromA"
}

Keep in mind the order of the arrays.