Una pregunta bastante simple. Cuál es la diferencia entre:
$merged = array_merge($array1, $array2);
y
$merged = $array1 + $array2;
?
Una pregunta bastante simple. Cuál es la diferencia entre:
$merged = array_merge($array1, $array2);
y
$merged = $array1 + $array2;
?
Respuestas:
La diferencia es:
El +
operador toma la unión de las dos matrices, mientras que la array_merge
función toma la unión PERO las claves duplicadas se sobrescriben.
array_merge
realmente hace ... 3. Y vea la respuesta de BoltClock sobre otra diferencia crucial que no se menciona aquí: array_merge
restablece las teclas numéricas, a diferencia de +
.
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.
Fuente: https://softonsofa.com/php-array_merge-vs-array_replace-vs-plus-aka-union/
Deje de usar array_merge ($ defaults, $ options):
function foo(array $options)
{
$options += ['foo' => 'bar'];
// ...
}
Nota : la función array_replace existe desde PHP5.3.
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_merge
actally 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_merge
matrices 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'
Creo que array_merge
sobrescribe las claves $array1 + $array2
no numéricas duplicadas mientras que no lo hace.
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
)
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
)
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.
$a+$b
vs $b+$a
. No se anula nada.