Array replace: примеры (PHP)

<?php
$base = ['a' => 1, 'b' => 2, 'c' => 3];
$replace = ['b' => 20, 'c' => 30];
$result = array_replace($base, $replace);
print_r($result);
?>

Array
(
    [a] => 1
    [b] => 20
    [c] => 30
)

<?php
$base = ['a' => 1, 'b' => 2];
$rep1 = ['b' => 22, 'c' => 33];
$rep2 = ['c' => 333, 'd' => 44];
$result = array_replace($base, $rep1, $rep2);
print_r($result);
?>

Array
(
    [a] => 1
    [b] => 22
    [c] => 333
    [d] => 44
)

<?php
$base = [0 => 'apple', 1 => 'banana'];
$replace = [1 => 'orange', 2 => 'grape'];
$result = array_replace($base, $replace);
print_r($result);
?>

Array
(
    [0] => apple
    [1] => orange
    [2] => grape
)

Функция array_merge() объединяет массивы. Ключевое отличие от array_replace() – поведение с числовыми ключами. array_merge() переиндексирует числовые ключи, начиная с нуля, в то время как array_replace() сохраняет исходные ключи. Для строковых ключей поведение одинаковое: значения из более поздних массивов перезаписывают предыдущие.

<?php
$arr1 = [0 => 'a', 1 => 'b'];
$arr2 = [1 => 'c', 2 => 'd'];
print_r(array_merge($arr1, $arr2));
print_r(array_replace($arr1, $arr2));
?>

Array ( [0] => a [1] => b [2] => c [3] => d )
Array ( [0] => a [1] => c [2] => d )

Оператор + для массивов объединяет их, но добавляет только те ключи из правого массива, которых нет в левом. Это означает, что значения из левого массива никогда не перезаписываются.

<?php
$arr1 = ['a' => 1, 'b' => 2];
$arr2 = ['b' => 3, 'c' => 4];
print_r($arr1 + $arr2);
?>

Array ( [a] => 1 [b] => 2 [c] => 4 )

Функция array_replace_recursive() работает аналогично array_replace(), но производит замену рекурсивно для вложенных массивов.

Если первый аргумент не является массивом, функция вернет null и может сгенерировать предупреждение (E_WARNING) в зависимости от версии PHP.

<?php
$result = array_replace(null, ['a' => 1]);
var_dump($result);
?>

NULL
Warning: array_replace(): Argument #1 must be of type array, null given

array_replace() не работает рекурсивно. Для замены значений во вложенных массивах следует использовать array_replace_recursive().

<?php
$base = ['settings' => ['color' => 'red', 'size' => 'M']];
$replace = ['settings' => ['size' => 'L']];
$result = array_replace($base, $replace);
print_r($result);
?>

Array
(
    [settings] => Array
        (
            [size] => L
        )
)

В примере выше весь подмассив settings был заменён, а не объединён. Ключ color потерян.

В PHP 8.0 поведение функции array_replace() не претерпело значительных изменений по сравнению с PHP 7. Основные особенности работы сохранились. Однако, как и для многих внутренних функций, в PHP 8 была усилена система типов. Передача аргументов некорректного типа (например, null вместо массива) теперь вызывает TypeError, если включён строгий режим, или генерирует предупреждение с последующим возвратом null.

В более ранних версиях, до PHP 7.4, также не было критичных изменений в логике работы этой функции.

<?php
// Цель: заменить значения с сохранением ключей, но добавить новые элементы
// с переиндексацией числовых ключей для новых значений.
$config = ['host' => 'localhost', 'port' => 80, 0 => 'default'];
$override = ['port' => 8080, 1 => 'new_item', 'host' => '127.0.0.1'];

// array_replace сохранит ключи 0 и 1 как есть.
$replaced = array_replace($config, $override);
print_r($replaced);
?>

Array
(
    [host] => 127.0.0.1
    [port] => 8080
    [0] => default
    [1] => new_item
)

<?php
// Может быть полезно для задания значений по умолчанию
$defaults = ['timeout' => 30, 'mode' => 'fast', 'retry' => false];
$userInput = ['mode' => 'slow'];

$options = array_replace($defaults, $userInput);

// Деструктуризация массива
['timeout' => $timeout, 'mode' => $mode, 'retry' => $retry] = $options;
echo "Timeout: $timeout, Mode: $mode, Retry: " . ($retry ? 'true' : 'false');
?>

Timeout: 30, Mode: slow, Retry: false

<?php
// Если один из массивов замены пуст или не передан
$base = ['a' => 1];
$result1 = array_replace($base, []); // Ничего не меняется
$result2 = array_replace($base); // Возвращает копию $base
print_r([$result1, $result2]);
?>

Array
(
    [0] => Array
        (
            [a] => 1
        )
    [1] => Array
        (
            [a] => 1
        )
)

<?php
// Если требуется замена только на первом уровне вложенности,
// но для некоторых ключей нужна рекурсия, можно комбинировать функции.
$base = ['data' => ['a' => 1, 'b' => 2], 'flag' => true];
$replace = ['data' => ['b' => 20], 'flag' => false];

// Это перезапишет весь 'data'
// $result = array_replace($base, $replace);

// А это выполнит рекурсивную замену для 'data' и обычную для 'flag'
$result = array_replace($base, $replace);
$result['data'] = array_replace($base['data'], $replace['data']);
print_r($result);
?>

Array
(
    [data] => Array
        (
            [a] => 1
            [b] => 20
        )
    [flag] => false
)

<?php
// array_replace корректно заменяет значения, даже если они равны null
$base = ['a' => 1, 'b' => null];
$replace = ['b' => 2, 'c' => 3];
$result = array_replace($base, $replace);
print_r($result);
?>

Array
(
    [a] => 1
    [b] => 2
    [c] => 3
)

В JavaScript похожий результат достигается с помощью spread оператора ... для объектов или функции Object.assign().

// Spread оператор (ES6+)
const base = { a: 1, b: 2, c: 3 };
const replace = { b: 20, c: 30 };
const result = { ...base, ...replace };
console.log(result);

{ a: 1, b: 20, c: 30 }

// Object.assign
const result2 = Object.assign({}, base, replace);
console.log(result2);

# Метод update (изменяет исходный словарь)
base = {'a': 1, 'b': 2, 'c': 3}
replace = {'b': 20, 'c': 30}
result = base.copy()
result.update(replace)
print(result)  # {'a': 1, 'b': 20, 'c': 30}

# Распаковка словарей (Python 3.5+)
result2 = {**base, **replace}
print(result2)

{'a': 1, 'b': 20, 'c': 30}

В SQL нет прямой аналогии для работы с массивами. Подобная логика может быть реализована через условные выражения (CASE) или объединение запросов (UNION/JOIN) на уровне строк таблицы, но концепция сильно отличается.