Using PHP's union operator ( ) can effectively merge arrays and preserve key names, especially for associative arrays. 1. The union operator is based on the key value of the left array, and only adds it if the key of the right array does not exist on the left; 2. This feature is suitable for configuring merge scenarios, such as filling in missing items configured by the user with default values, and will not overwrite existing settings; 3. For indexed arrays, array_merge() should be used instead of the union operator, because the numeric keys will conflict, causing the right element to be ignored; 4. When using it, the default array should be placed on the right, supporting chain operations and not modifying the original array; 5. Ensure that all operands are arrays to avoid warnings. Therefore, when it is necessary to preserve existing key values and only fill in voids, the union operator is the best choice.

When combining arrays in PHP, preserve keys—especially when working with associated arrays—is often critical to maintaining data integrity. One of the most effective and underappreciated tools for this task is the union operator ( ). Unlike functions like array_merge() , the union operator offers a unique behavior that can help you combine arrays while respecting key preservation in a strategic way.

How the Union Operator Works

The union operator ( ) merges two or more arrays such that:

• Keys from the left operand take precedence.
• Elements from the right operand are only added if their keys don't already exist in the left array.
• All original keys (including strings and integers) are preserved.

 $array1 = ['a' => 1, 'b' => 2, 'c' => 3];
$array2 = ['c' => 10, 'd' => 4, 'e' => 5];

$result = $array1 $array2;

// Results: ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5]

Notice that the value of key 'c' remains 3 from $array1 , because the union operator keeps the first encountered value for any duplicate key.

This behavior makes it ideal for scenarios like applying defaults without overwriting existing settings.

Use Case: Config Merging with Defaults

A common real-world application is merged user-defined configuration with default values.

 $defaults = [
    'host' => 'localhost',
    'port' => 3306,
    'debug' => false,
    'timeout' => 30
];

$userConfig = [
    'host' => 'example.com',
    'debug' => true
];

$config = $userConfig $defaults;

// Results:
// [
// 'host' => 'example.com',
// 'debug' => true,
// 'port' => 3306,
// 'timeout' => 30
// ]

Here, user preferences are preserved, and only missing keys are filled in from defaults. This prevents accidental overrides and give priority to explicitly set values.

Compare this to array_merge($defaults, $userConfig) , which would correctly override defaults—but if you reverse the order, you risk overwriting intentional defaults unless you're careful.

Key Preservation: Indexed vs. Associative Arrays

Be mindful when using the union operator with indexed (numeric) arrays :

 $a = [1, 2];
$b = [3, 4];

var_dump($a $b);
// Results: [1, 2] — values from $b are ignored due to key collision (0 and 1 exist in $a)

Unlike associated keys, numeric indices are not treated uniquely in unions. So for indexed arrays, is rarely useful. In such cases, use array_merge() instead.

So remember:

• Use union ( ) for associate arrays where key preservation and non-overwrite semantics matter.
• Use array_merge() for indexed arrays or when you want the right most value to win.

Strategic Tips for Using the Union Operator

• Right-to-left defaults : To apply defaults, always place them on the right side: $specific $defaults .
• Immutable pattern : The union operator doesn't modify original arrays—it returns a new one. This supports functional-style programming.
• Multiple arrays : You can chain unions: $a $b $c . Evaluation is left-associative, so precedence flows left to right.
• Type safety : Ensure both operands are arrays. Using with non-arrays triggers warnings.

Final Thoughts

The union operator is a quiet powerhouse in PHP's array toolkit. When your goal is to combine arrays while preserving existing keys and avoiding overwrites, it's often the cleanest, most predictable option—especially in configuration systems, fallback logic, or feature flag management.

Just remember: it's not about merging everything, but about merging strategically . And sometimes, the simplest operator does the job best.

Basically, if you want to keep what you already have and only fill in the gaps, reach for .

The above is the detailed content of Strategic Array Combination: Preserving Keys with the Union Operator. For more information, please follow other related articles on the PHP Chinese website!