Qual è la differenza tra array_merge e array + array?

Una domanda abbastanza semplice. Qual è la differenza tra:

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

e

$merged = $array1 + $array2;

?

La differenza è:

L' +operatore prende l'unione dei due array, mentre la array_mergefunzione prende l'unione MA le chiavi duplicate vengono sovrascritte.

Ecco un semplice test illustrativo:

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

con il risultato:

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
)

Si noti che le chiavi non numeriche duplicate assumeranno il primo valore utilizzando l'operatore di unione ma il secondo utilizzando array_merge.

Per le chiavi numeriche, il primo valore verrà utilizzato con l'operatore union mentre tutti i valori verranno utilizzati con array_merge, appena reindicizzati.

In genere uso l'operatore union per array associativi e array_merge per numerico. Naturalmente, puoi anche usare array_merge per associativo, solo che i valori successivi sovrascrivono quelli precedenti.

array_merge()fa sì che tutti i tasti numerici trovati negli array di input vengano reindicizzati nell'array risultante. L'operatore sindacale +non causa una reindicizzazione.

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

Smetti di usare array_merge ($ defaults, $ opzioni):

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

   // ...
}

Nota : la funzione array_replace esiste da PHP5.3.

Il segno + prende solo il valore dalla prima occorrenza di una chiave di matrice.
array_merge prende il valore dall'ultima occorrenza di una chiave di matrice.

Esempio:

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

Questo produce:

segno più unisci
matrice (4) {
["a"] =>
stringa (3) "uno"
["b"] =>
stringa (3) "due"
["c"] =>
stringa (5) "tre"
[3] =>
stringa (12) "numero tre"
}

funzione array_merge merge
array (4) {
["a"] =>
stringa (6) "quarto"
["b"] =>
stringa (5) "quinto"
["c"] =>
stringa (5) "sesto"
[0] =>
stringa (12) "numero tre"
}

È interessante notare che in questo array_mergecaso cancella effettivamente l'indice "3" del numero tre anche se è una stringa, perché è un numero.

Quindi fai attenzione quando ti unisci ad array_mergearray con indici numerici. Potrebbero perdere le chiavi. se sono importanti per te, precedili con una stringa.

quindi invece di '3' => 'three'usare qualcosa di simile'_3' => 'three'

Credo che array_mergesovrascriva le chiavi $array1 + $array2non numeriche duplicate mentre non lo fa.

Ancora un altro esempio (array senza chiavi esplicite; è ovvio riguardo a come funzionano l'operatore +e il array_mergefunzionamento, ma le cose "ovvie" sono più semplici se viste;))

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

darà:

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

Si prega di prestare attenzione a un'altra differenza: l'unione (+) non sovrascriverà un valore non vuoto con un valore vuoto (considerando una stessa chiave), mentre array_merge:

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

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

Uscite:

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

Quindi apparentemente se cambi l'ordine, sia l'unione che l'unione faranno la stessa cosa

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

Uscite:

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

Tieni presente l'ordine degli array.