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


Respuestas:


73

La diferencia es:

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


Entonces, ¿cuál es la diferencia entre estos 2: array_merge , plus sign (aunque tuve que cambiar las matrices)?
Joseph Silber

15
Una advertencia para los principiantes aquí, el resultado de la operación en ambos casos es nulo si cualquiera de las matrices es nulo . Es posible que a algunos no les importe esto asumiendo que, dado que se trata de una operación de unión, el resultado será la matriz adecuada (no nula) si una de ellas es nula . Pero, eso es cierto si una de las matrices es una matriz vacía. Entonces, como una buena práctica, creo que deberíamos inicializar las matrices de entrada como matrices vacías. ¿Qué dicen ustedes?
Sandeepan Nath

6
Si hay claves duplicadas, "tomar la unión" siempre tendrá que deshacerse de una de ellas. La diferencia está en cuál.
alexis

5
Lo siento, esta respuesta es confusa, incorrecta e incompleta. : -o Vea el comentario de @ alexis con respecto al bit confuso (aunque el suyo también es solo la mitad de la verdad con respecto al OP). 2. Vea la respuesta de Yehosef sobre lo que array_merge realmente hace ... 3. Y vea la respuesta de BoltClock sobre otra diferencia crucial que no se menciona aquí: array_mergerestablece las teclas numéricas, a diferencia de +.
Sz.

no específico en absoluto. no es útil. no resalta la diferencia. demasiado alto nivel de explicación.
ahnbizcad

90

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
)

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

Para las claves numéricas, el primer valor se usará con el operador de unión, mientras que todos los valores se usarán con array_merge, recién indexado.

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 a los anteriores.


52

array_merge()hace que todas las claves numéricas que se encuentran en las matrices de entrada se vuelvan a indexar en la matriz resultante. El operador sindical +no provoca una reindexación.



20

El signo + solo toma el valor de la primera aparición de una clave 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:

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

array_merge función merge
array (4) {
["a"] =>
cadena (6) "cuarta"
["b"] =>
cadena (5) "quinta"
["c"] =>
cadena (5) "sexta"
[0] =>
cadena (12) "número tres"
}

Es interesante notar en esto que el array_mergeactally 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 fusionar array_mergematrices con índices numéricos. Pueden perder sus llaves. si son importantes para usted, precedalas con una cadena.

así que en lugar de '3' => 'three'usar algo como'_3' => 'three'


5
" aunque sea una cadena, porque es un número " merece un +1 :-)
e2-e4

5

Creo que array_mergesobrescribe las claves $array1 + $array2no numéricas duplicadas mientras que no lo hace.


3

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
)

0

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

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

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

Salidas:

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

0

Entonces, aparentemente, si cambia el orden, tanto la unión como la fusión harán lo mismo

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

Salidas:

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

Tenga en cuenta el orden de las matrices.


Ha cambiado el orden: $a+$bvs $b+$a. No se anula nada.
ZbyszekKr

Vaya, 🤔 @ ZbyszekKr gracias. No sé cómo me perdí eso. Volveré a visitar y editaré mi respuesta.
Nedyalko Dyakov
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.