В чем разница между array_merge и array + array?

116

Довольно простой вопрос. Какая разница между:

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

и

$merged = $array1 + $array2;

?

Разработчик Pixel
источник
6
возможный дубликат оператора + для массива в PHP?
Гордон
3
вероятно, Гордон пропустил это из-за того, что в заголовке нет array_merge.
The Pixel Developer

Ответы:

73

Разница в следующем:

+Оператор принимает объединение двух массивов, в то время как array_mergeфункция принимает объединение НО дублирующие ключи будут перезаписаны.

Майк Льюис
источник
Итак, в чем разница между этими 2: array_merge , знак плюс (хотя мне пришлось перейти вокруг массивов)?
Джозеф Зильбер,
15
Предупреждение для новичков: результат операции в обоих случаях равен нулю, если какой-либо из массивов равен нулю . Некоторые могут не заботиться об этом, предполагая, что, поскольку это операция объединения, результатом будет правильный (не нулевой) массив, если один из них имеет значение NULL . Но это верно, если один из массивов является пустым. Поэтому я считаю хорошей практикой инициализировать входные массивы как пустые. Что вы скажете, ребята?
Sandeepan Nath
6
Если есть повторяющиеся ключи, «взяв объединение» всегда придется избавляться от одного из них. Разница в том, в каком.
Alexis
5
Извините, этот ответ сбивает с толку, неверен и неполон. : -o См. комментарий @ alexis относительно запутанного бита (хотя это также лишь половина правды относительно OP). 2. См . Ответ Йехосефа о том, что на array_merge самом деле делает ... 3. И см . Ответ BoltClock о другом важном отличии, не упомянутом здесь: array_mergeсбрасывает цифровые клавиши, в отличие от +.
Sz.
совсем не конкретный. не полезно. не подчеркивает разницу. слишком высокий уровень объяснения.
ahnbizcad 01
90

Вот простой наглядный тест:

$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));

с результатом:

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
)

Обратите внимание, что повторяющиеся нечисловые ключи будут принимать первое значение с помощью оператора объединения, а второе с использованием array_merge.

Для числовых ключей первое значение будет использоваться с оператором объединения, тогда как все значения будут использоваться с array_merge, только что переиндексированным.

Обычно я использую оператор объединения для ассоциативных массивов и array_merge для числовых. Конечно, вы можете также использовать array_merge для ассоциативности, просто чтобы более поздние значения перезаписывали более ранние.

Yehosef
источник
52

array_merge()заставляет все числовые ключи, найденные во входных массивах, переиндексироваться в результирующем массиве. Оператор объединения +не вызывает переиндексацию.

BoltClock
источник
29

array_merge против плюс

Источник: https://softonsofa.com/php-array_merge-vs-array_replace-vs-plus-aka-union/

Прекратите использовать array_merge ($ defaults, $ options):

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

   // ...
}

Примечание : функция array_replace существует с PHP5.3.

Лучаниновыми
источник
почему мы должны прекратить использовать array_merge ($ default, $ options) :? потому что он запрещает неиндексированные ключи?
ahnbizcad
но ответ действительно дидактическая +1
ОСШ
20

Знак + принимает только значение из первого появления ключа массива.
array_merge принимает значение из последнего вхождения ключа массива.

Пример:

$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);

Это выводит:


массив слияния со знаком плюса (4) {
["a"] =>
строка (3) "one"
["b"] =>
строка (3) "two"
["c"] =>
строка (5) "three"
[3] =>
строка (12) «номер три»
}

array_merge function merge
array (4) {
["a"] =>
строка (6) "четвертая"
["b"] =>
строка (5) "пятая"
["c"] =>
строка (5) "шестая"
[0] =>
строка (12) "номер три"
}

Интересно отметить, что на array_mergeсамом деле стирает в «3» индекс номер три , даже если это строка, потому что это число.

Так что будьте осторожны при слиянии с array_merge массивами с числовыми индексами. Они могут потерять ключи. если они важны для вас, поставьте перед ними строку.

поэтому вместо '3' => 'three'использования чего-то вроде'_3' => 'three'

Tschallacka
источник
5
« хотя это строка, потому что это число » заслуживает +1 :-)
e2-e4
5

Я считаю, что array_mergeперезаписывает повторяющиеся non_numeric ключи, а $array1 + $array2этого нет.

Klennepette
источник
3

Еще один пример (массивы без явных ключей; это очевидно относительно того, как работает оператор +и array_merge, но "очевидные" вещи проще на вид;))

$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));

дам:

$a + $b = Array
(
    [0] => apple
    [1] => lemon
)
array_merge($a, $b) = Array
(
    [0] => apple
    [1] => orange
    [2] => lemon
)
jacek.ciach
источник
0

Обратите внимание на еще одно отличие: объединение (+) не будет перезаписывать непустое значение пустым значением (с учетом того же ключа), тогда как array_merge:

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

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

Выходы:

Array
(
    [foo] => bar
)
Array
(
    [foo] => 0
)
ЗалемГорожанин
источник
0

Очевидно, если вы измените порядок, объединение и слияние будут делать то же самое.

$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));

Выходы:

$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"
}

Помните о порядке массивов.

Недялко Дьяков
источник
Вы изменили порядок: $a+$bпротив $b+$a. Ничего не отменяется.
ZbyszekKr
Ой, @ ZbyszekKr, спасибо. Не знаю, как я это пропустил. Вернусь и отредактирую свой ответ.
Недялко Дьяков