php - concatenar - ¿Cuál es la diferencia entre array_merge y array+array?

concatenar arrays php

Question

Una pregunta bastante simple. Cuál es la diferencia entre:

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

y

$merged = $array1 + $array2;

?

Answer 1

Aquí hay una prueba ilustrativa 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));

con el resultado:

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
)

Observe que las claves no numéricas duplicadas tomarán el primer valor utilizando el operador de unión, pero el último utilizando el array_merge.

Para las teclas numéricas, el primer valor se usará con el operador de unión, mientras que todos los valores se usarán con la matriz_mergen, solo se volverá a indexar.

Generalmente uso el operador de unión para matrices asociativas y array_merge para numérico. Por supuesto, también puede usar array_merge para asociativo, solo que los valores posteriores sobrescriben los anteriores.

Answer 2

Creo que array_merge sobrescribe claves non_numeric duplicadas, mientras que $array1 + $array2 no lo hace.

Answer 3

El signo + solo toma el valor de la primera ocurrencia de una tecla de matriz.
array_merge toma el valor de la última aparición de una clave de matriz.

Ejemplo:

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

Esto produce:

combinación de signo más
array (4) {
["a"] =>
cadena (3) "uno"
["b"] =>
cadena (3) "dos"
["c"] =>
cadena (5) "tres"
[3] =>
cadena (12) "número tres"
}

fusión de funciones array_merge
array (4) {
["a"] =>
cadena (6) "cuarto"
["b"] =>
cadena (5) "quinto"
["c"] =>
cadena (5) "sexto"
[0] =>
cadena (12) "número tres"
}

Es interesante notar que este array_merge borra el índice ''3'' del número tres a pesar de que es una cadena, porque es un número.

Así que tenga cuidado al fusionarse con matrices array_merge con índices numéricos. Podrían perder sus llaves. si son importantes para ti, prepáralos con una cuerda.

entonces en lugar de ''3'' => ''three'' usa algo como ''_3'' => ''three''

Answer 4

La diferencia es:

El operador + toma la unión de las dos matrices, mientras que la función array_merge toma la unión, PERO las claves duplicadas se sobrescriben).

Answer 5

No puedo comentar sobre la respuesta, así que escribiré otra.

@ZalemCitizen simplemente está equivocado, la unión (+) SOBREescribirá los valores no vacíos con los vacíos:

$a = array(''foo'' => ''bar'');
$b = array(''foo'' => null);

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

Productos:

array(1) {
  ["foo"]=>
  NULL
}
array(1) {
  ["foo"]=>
  NULL
}

Tenga en cuenta el orden de las matrices.

Answer 6

Otro ejemplo más (matrices sin claves explícitas; es obvio con respecto a cómo funcionan el operador + y array_merge , pero las cosas "obvias" son más simples cuando se ven;))

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

Answer 7

Preste atención a otra diferencia: la unión (+) no sobrescribirá el valor no vacío con el valor vacío (considerando una misma clave), mientras que array_merge hará lo siguiente:

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

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

Productos:

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

Answer 8

array_merge() hace que todas las claves numéricas encontradas en las matrices de entrada sean reindexadas en la matriz resultante. El operador de unión + no causa un reindex.