web-dev-qa-db-fra.com

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;

?

phparraysmergeaddition
95
The Pixel Developer

La différence est:

L'opérateur + prend l'union des deux tableaux alors que la fonction array_merge prend l'unionMAISles clés dupliquées sont écrasées).

59
Mike Lewis

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 en double non numériques prendront la première valeur à l'aide de l'opérateur union, mais la dernière à l'aide de 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 array_merge, juste réindexé.

J'utilise généralement l'opérateur d'union pour les tableaux associatifs et array_merge pour le numérique. Bien sûr, vous pouvez aussi bien utiliser array_merge pour associative, mais simplement que les valeurs les plus récentes écrasent les valeurs précédentes.

73
Yehosef

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 d'union + ne provoque pas de réindexation.

47
BoltClock

Le signe + prend uniquement la valeur de l'occurrence first d'une clé de tableau.
array_merge prend la valeur de l'occurrence last 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 génère:

fusion du signe plus
tableau (4) {
["a"] =>
string (3) "un"
["b"] =>
string (3) "deux"
["c"] =>
string (5) "trois"
[3] =>
string (12) "numéro trois"
} 

array_merge function fusion
tableau (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 que le array_merge agit réellement efface l’index "3" du numéro trois même s’il s’agit d’une chaîne, car c’est un nombre.

Faites donc attention lorsque vous fusionnez avec des tableaux array_merge avec des index numériques. Ils risquent de perdre leurs clés. s'ils sont importants pour vous, faites-les précéder d'une chaîne.

donc au lieu de '3' => 'three', utilisez quelque chose comme '_3' => 'three'

18
Tschallacka

Je crois que array_merge remplace les clés en double non numériques, alors que $array1 + $array2 ne le fait pas.

5
klennepette

 array_merge vs plus

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

   // ...
}

Note: la fonction array_replace existe depuis PHP 5.3.

3
luchaninov

Encore un autre exemple (tableaux sans clés explicites; il est évident que l’opérateur + et array_merge fonctionnent, mais les éléments "évidents" sont plus simples à la vue;))

$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
)
3
jacek.ciach

Donc, apparemment, si vous modifiez 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.

0
Nedyalko Dyakov

Faites attention à une autre différence: l'union (+) n'écrase pas les valeurs non vides avec des valeurs vides (en considérant une même clé), alors que array_merge va

$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
)
0
ZalemCitizen