Fusionar dos arreglos con el “+” (operador de unión de arreglos) ¿Cómo funciona?

Tengo un código que parece fusionar los datos de dos matrices usando +=, pero no incluye todos los elementos del elemento. ¿Como funciona?

Ejemplo:

$test = array('hi');
$test += array('test', 'oh');
var_dump($test);

Producción:

array(2) {
  [0]=>
  string(2) "hi"
  [1]=>
  string(2) "oh"
}

Que hace + significa cuando se usa en matrices en PHP?

Citando de la Manual de PHP sobre operadores de lenguaje

El operador + devuelve la matriz de la derecha añadida a la matriz de la izquierda; para las claves que existen en ambas matrices, se utilizarán los elementos de la matriz de la izquierda y se ignorarán los elementos coincidentes de la matriz de la derecha.

entonces si lo haces

$array1 = ['one',   'two',          'foo' => 'bar'];
$array2 = ['three', 'four', 'five', 'foo' => 'baz']; 

print_r($array1 + $array2);

Conseguirás

Array
(
    [0] => one   // preserved from $array1 (left-hand array)
    [1] => two   // preserved from $array1 (left-hand array)
    [foo] => bar // preserved from $array1 (left-hand array)
    [2] => five  // added from $array2 (right-hand array)
)

Entonces la lógica de + es equivalente al siguiente fragmento:

$union = $array1;

foreach ($array2 as $key => $value) {
    if (false === array_key_exists($key, $union)) {
        $union[$key] = $value;
    }
}

Si está interesado en los detalles de la implementación de nivel C, diríjase a

• php-src/Zend/operadores_zend.c

Tenga en cuenta que + es diferente de como array_merge() combinaría las matrices:

print_r(array_merge($array1, $array2));

te daría

Array
(
    [0] => one   // preserved from $array1
    [1] => two   // preserved from $array1
    [foo] => baz // overwritten from $array2
    [2] => three // appended from $array2
    [3] => four  // appended from $array2
    [4] => five  // appended from $array2
)

Consulte las páginas vinculadas para obtener más ejemplos.

El mejor ejemplo que encontré para usar esto está en una matriz de configuración.

$user_vars = array("username"=>"John Doe");
$default_vars = array("username"=>"Unknown", "email"=>"no-reply@domain.com");

$config = $user_vars + $default_vars;

El $default_vars, como sugiere, es la matriz de valores predeterminados. El $user_vars matriz sobrescribirá los valores definidos en $default_vars. Cualquier valor faltante en $user_vars ahora son las variables predeterminadas de $default_vars.

Esto sería print_r como:

Array(2){
    "username" => "John Doe",
    "email" => "no-reply@domain.com"
}

¡Espero que esto ayude!

Este operador toma la unión de dos matrices (igual que array_merge, excepto que con array_merge se sobrescriben las claves duplicadas).

La documentación para los operadores de matriz se encuentra aquí.

Ojo con las teclas numéricas, si deben conservarse o si no quieres perder nada

$a = array(2 => "a2", 4 => "a4", 5 => "a5");
$b = array(1 => "b1", 3 => "b3", 4 => "b4");

Unión

print_r($a+$b);
Array
(
    [2] => a2
    [4] => a4
    [5] => a5
    [1] => b1
    [3] => b3
)

unir

print_r(array_merge($a, $b));
Array
(
    [0] => a2
    [1] => a4
    [2] => a5
    [3] => b1
    [4] => b3
    [5] => b4
)

El + operador produce los mismos resultados que array_replace(). Sin embargo, dado que los argumentos del operador están invertidos, el orden de la matriz resultante también puede ser diferente.

Ampliando otro ejemplo de esta página:

$array1 = array('one', 'two', 'foo' => 'bar');
$array2 = array('three', 'four', 'five', 'foo' => 'baz'); 

print_r($array1 + $array2);
print_r(array_replace($array2, $array1)); //note reversed argument order

salidas:

Array
(
    [0] => one   // preserved from $array1
    [1] => two   // preserved from $array1
    [foo] => bar // preserved from $array1
    [2] => five  // added from $array2
)
Array
(
    [0] => one   // preserved from $array1
    [1] => two   // preserved from $array1
    [2] => five  // added from $array2
    [foo] => bar // preserved from $array1
)

1. La operación Array plus trata a todos los arrays como arrays asociados.
2. Cuando la clave entra en conflicto durante más, se mantendrá el valor izquierdo (anterior)

Publico el código a continuación para aclarar las cosas.

$a + $b = array_plus($a, $b)

function array_plus($a, $b){
    $results = array();
    foreach($a as $k=>$v) if(!isset($results[$k]))$results[$k] = $v;
    foreach($b as $k=>$v) if(!isset($results[$k]))$results[$k] = $v;
    return $results;
}

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

Dicho esto, podríamos pensar que el operador + es un poco redundante, ya que se puede lograr lo mismo con la función array_replace.

Sin embargo, hay casos en los que resulta útil: supongamos que tiene una matriz de opciones de $ que se pasa a una función/método, y también hay valores predeterminados para usar como respaldo:

// we could do it like this
function foo(array $options)
{
   $defaults = ['foo' => 'bar'];
   
   $options = array_replace($defaults, $options);
 
   // ...
}
 
// but + here might be way better:
function foo(array $options)
{
   $options += ['foo' => 'bar'];
 
   // ...
}