Use array_merge() to simply overwrite the update of the original array with the value of the second array; 2. Use the union operator ( ) to retain the original array value and only add missing keys (suitable for setting the default value); 3. Fine-grained control can be achieved through foreach combined with conditional judgment, such as updating only non-null values; 4. For nested arrays, array_replace_recursive() should be used to achieve deep updates; 5. When updating, array_key_exists() or isset() should always be used to safely check the existence of keys to avoid errors; these methods cover the main scenarios in PHP for updating arrays based on another array, and appropriate methods should be selected according to the data structure and logic to ensure that the operation is safe and effective.

When working with PHP, you'll often need to update one array based on the values from another—especially when dealing with form data, database records, or configuration settings. This operation can involve merging, overwriting, or selectively updating elements. Here's how to do it effectively and safely.

1. Using array_merge() for Simple Updates

The most straightforward way to update an array with values from another is array_merge() . It combines arrays, with later values overwriting earlier ones for matching keys.

 $original = [
    'name' => 'John',
    'email' => 'john@example.com',
    'age' => 30
];

$updates = [
    'email' => 'john.doe@example.com',
    'age' => 31
];

$updated = array_merge($original, $updates);

// Results:
// [
// 'name' => 'John',
// 'email' => 'john.doe@example.com',
// 'age' => 31
// ]

Note: array_merge() only works reasonably with string or numeric keys. If the arrays have numeric keys, values are reindexed and appended.

2. Using the Union Operator ( ) to Preserve Original Values

If you want to update only missing keys (ie, default values), use the union operator. It keeps the first array's values and adds only keys not present in it.

 $defaults = [
    'name' => 'Anonymous',
    'status' => 'inactive',
    'role' => 'user'
];

$provided = [
    'name' => 'Alice',
    'status' => 'active'
];

$result = $provided $defaults;

// Results: Only adds 'role' from defaults
// [
// 'name' => 'Alice',
// 'status' => 'active',
// 'role' => 'user'
// ]

This is useful for setting defaults without overwriting user input.

3. Selective Update with foreach and Conditions

Sometimes you want more control—like updating only non-empty values or validating before update.

 foreach ($updates as $key => $value) {
    if (array_key_exists($key, $original)) {
        // Only update existing keys
        $original[$key] = $value;
    }
}

Or update only if the new value is not null:

 foreach ($updates as $key => $value) {
    if ($value !== null) {
        $original[$key] = $value;
    }
}

This gives you full control over the update logic.

4. Handling Nested Arrays with array_replace_recursive()

For multi-dimensional arrays, array_merge() won't deeply merge nested structures. Use array_replace_recursive() instead.

 $config = [
    'database' => [
        'host' => 'localhost',
        'port' => 3306,
        'username' => 'root'
    ],
    'debug' => true
];

$overrides = [
    'database' => [
        'host' => '192.168.1.100',
        'username' => 'admin'
    ],
    'debug' => false
];

$newConfig = array_replace_recursive($config, $overrides);

Now both host and username inside database are updated, while port remains unless overridden.

Note: array_replace_recursive() does not merge keys that are arrays in one but not the other in the same way—be cautious with mixed types.

5. Using array_key_exists() or isset() for Safety

Always check if a key exists before using it, especially when the update array comes from user input or external sources.

 if (array_key_exists('email', $updates)) {
    $original['email'] = $updates['email'];
}

Use isset() if you want to skip null values:

 if (isset($updates['email'])) {
    $original['email'] = $updates['email'];
}

Summary

• Use array_merge() to overwrite values with a second array.
• Use $updates $defaults to fill in missing values.
• Use foreach with conditions for fine-grained control.
• Use array_replace_recursive() for nested arrays.
• Always validate keys and values when updating from untrusted sources.

These techniques cover most real-world scenarios for updating PHP arrays based on another. Choose the method that fits your data structure and update logic.

The above is the detailed content of Updating a PHP Array Based on Values from Another Array. For more information, please follow other related articles on the PHP Chinese website!