Was ist der Unterschied zwischen array_merge und array + array?

Eine ziemlich einfache Frage. Was ist der Unterschied zwischen:

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

und

$merged = $array1 + $array2;

?

Der Unterschied ist:

Der +Operator übernimmt die Vereinigung der beiden Arrays, während die array_mergeFunktion die Vereinigung übernimmt, ABER die doppelten Schlüssel werden überschrieben.

Hier ist ein einfacher illustrativer 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));

mit dem Ergebnis:

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
)

Beachten Sie, dass doppelte nicht numerische Schlüssel den ersten Wert mit dem Union-Operator, den späteren mit array_merge annehmen.

Bei numerischen Schlüsseln wird der erste Wert mit dem Vereinigungsoperator verwendet, während alle Werte mit dem gerade neu indizierten array_merge verwendet werden.

Ich verwende im Allgemeinen den Union-Operator für assoziative Arrays und array_merge für numerische. Natürlich können Sie auch array_merge für assoziative verwenden, nur dass die späteren Werte frühere überschreiben.

array_merge()bewirkt, dass alle in den Eingabearrays gefundenen numerischen Schlüssel im resultierenden Array neu indiziert werden. Der Gewerkschaftsoperator +verursacht keine Neuindizierung.

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

Verwenden Sie array_merge nicht mehr ($ defaults, $ options):

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

   // ...
}

Hinweis : Die Funktion array_replace ist seit PHP5.3 vorhanden.

Das + -Zeichen übernimmt nur den Wert von ersten Auftreten eines Array-Schlüssels an.
array_merge übernimmt den Wert aus dem letzten Vorkommen eines Array-Schlüssels.

Beispiel:

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

Dies gibt aus:

Pluszeichen-Zusammenführungsarray
(4) {
["a"] =>
Zeichenfolge (3) "eins"
["b"] =>
Zeichenfolge (3) "zwei"
["c"] =>
Zeichenfolge (5) "drei"
[3] =>
Zeichenfolge (12) "Nummer drei"
}

array_merge Funktion Merge
Array (4) {
["a"] =>
Zeichenfolge (6) "vierte"
["b"] =>
Zeichenfolge (5) "fünfte"
["c"] =>
Zeichenfolge (5) "sechste"
[0] =>
Zeichenfolge (12) "Nummer drei"
}

Interessant dabei ist, dass die array_merge actally löscht die sogar ‚3‘ Index der Nummer drei , obwohl es ein String ist, weil es sich um eine Zahl ist.

Seien Sie also vorsichtig, wenn Sie mit verschmelzen array_merge Arrays mit numerischen Indizes zusammenführen. Sie könnten ihre Schlüssel verlieren. Wenn sie für Sie wichtig sind, stellen Sie ihnen eine Zeichenfolge voran.

also anstatt so '3' => 'three'etwas zu benutzen'_3' => 'three'

Ich glaube, array_mergeüberschreibt doppelte nicht numerische Schlüssel, während $array1 + $array2dies nicht der Fall ist.

Noch ein weiteres Beispiel (Arrays ohne explizite Schlüssel; es ist offensichtlich, wie der Bediener +und die array_mergeArbeitsweise funktionieren, aber "offensichtliche" Dinge sind einfacher, wenn man sie sieht;))

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

wird geben:

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

Bitte beachten Sie einen weiteren Unterschied: Die Vereinigung (+) überschreibt nicht leere Werte nicht mit leeren Werten (unter Berücksichtigung des gleichen Schlüssels), während array_merge:

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

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

Ausgänge:

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

Wenn Sie also die Reihenfolge ändern, tun Union und Merge anscheinend dasselbe

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

Ausgänge:

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

Beachten Sie die Reihenfolge der Arrays.