Quelle est la différence entre array_merge et array + array?

Une question assez simple. Quelle est la différence entre:

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

et

$merged = $array1 + $array2;

?

La différence est:

L' +opérateur prend l'union des deux tableaux, alors que la array_mergefonction prend l'union MAIS les clés dupliquées sont écrasées.

Voici un test illustratif simple:

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

Avec le résultat:

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
)

Notez que les clés non numériques en double prendront la première valeur en utilisant l'opérateur union, mais la dernière en utilisant array_merge.

Pour les clés numériques, la première valeur sera utilisée avec l'opérateur union alors que toutes les valeurs seront utilisées avec le array_merge, juste réindexé.

J'utilise généralement l'opérateur union pour les tableaux associatifs et array_merge pour les nombres. Bien sûr, vous pouvez tout aussi bien utiliser array_merge pour associatif, simplement que les dernières valeurs écrasent les précédentes.

array_merge()provoque la réindexation de toutes les clés numériques trouvées dans les tableaux d'entrée dans le tableau résultant. L'opérateur union +ne provoque pas de réindexation.

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

Arrêtez d'utiliser array_merge ($ defaults, $ options):

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

   // ...
}

Remarque : la fonction array_replace existe depuis PHP5.3.

Le signe + prend uniquement la valeur de la première occurrence d'une clé de tableau.
array_merge prend la valeur de la dernière occurrence d'une clé de tableau.

Exemple:

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

Cela produit:

signe plus merge
array (4) {
["a"] =>
string (3) "one"
["b"] =>
string (3) "two"
["c"] =>
string (5) "three"
[3] =>
string (12) "numéro trois"
}

array_merge function merge
array (4) {
["a"] =>
string (6) "quatrième"
["b"] =>
string (5) "cinquième"
["c"] =>
string (5) "sixième"
[0] =>
string (12) "numéro trois"
}

Il est intéressant de noter dans ce que l' array_mergeactally efface l'indice « 3 » du numéro trois , même si elle est une chaîne, car il est un certain nombre.

Faites donc attention lors de la fusion avec des array_mergetableaux avec des index numériques. Ils pourraient perdre leurs clés. s'ils sont importants pour vous, faites-les précéder d'une chaîne.

donc au lieu d' '3' => 'three'utiliser quelque chose comme'_3' => 'three'

Je crois qu'il array_mergeécrase les clés non numériques en double alors que ce $array1 + $array2n'est pas le cas.

Encore un autre exemple (tableaux sans clés explicites; c'est évident en ce qui concerne la façon dont l'opérateur +et le array_mergetravail, mais les choses "évidentes" sont plus simples quand on les voit;))

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

va donner:

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

Veuillez faire attention à une autre différence: l'union (+) n'écrasera pas la valeur non vide par une valeur vide (en considérant une même clé), alors que array_merge:

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

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

Les sorties :

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

Donc, apparemment, si vous changez l'ordre, l'union et la fusion feront la même chose

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

Les sorties :

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

Gardez à l'esprit l'ordre des tableaux.