Php объединить массивы рекурсивно

array_merge_recursive

Функция array_merge_recursive() сливает элементы двух или более массивов таким образом, что значения одного массива присоединяются в конец другого. Возвращает результирующий массив.

Если входные массивы имеют одинаковые строковые ключи, то значения этих ключей сливаются в массив, и это делается рекурсивно, так что если одно из значений является массивом, то функция сливает его с соответствующим значением в другом массиве. Однако, если массивы имеют одинаковые числовые ключи, значение, упомянутое последним, не заменит исходное значение, а будет добавлено в конец массива.

Список параметров

Первоначальный массив для слияния.

Дополнительные рекурсивно сливаемые массивы.

Возвращаемые значения

Массив значений, полученный в результате слияния аргументов вместе.

Примеры

Пример #1 Пример использования array_merge_recursive()

$ar1 = array( «color» => array( «favorite» => «red» ), 5 );
$ar2 = array( 10 , «color» => array( «favorite» => «green» , «blue» ));
$result = array_merge_recursive ( $ar1 , $ar2 );
print_r ( $result );
?>

Результат выполнения данного примера:

Array ( [color] => Array ( [favorite] => Array ( [0] => red [1] => green ) [0] => blue ) [0] => 5 [1] => 10 )

Смотрите также

• array_merge() — Сливает один или большее количество массивов
• array_replace_recursive() — Рекурсивно заменяет элементы первого массива элементами переданных массивов

Источник

Функция array_merge_recursive в PHP

Если поднять вопрос об интересных и не совсем сходу понятных функциях, то я бы назвал array_merge_recursive .

На первый взгляд кажется что функция соединяет вроде бы как многомерные массивы, ведь для обычных уже есть array_merge или оператор + или оператор spread(. ).

Но если вы хотите все же соединить два многомерных массива в PHP, вы все равно должны использовать array_merge , а не array_merge_recursive . Почему?

Давайте сначала поймем, что array_merge_recursive делает, например, возьмем эти два массива:

$first = [ 
'key' => 'какое-то значение' 
]; 
 
$second = [ 
'key' => 'другое значение' 
];

array_merge_recursive($first, $second); 
 
// [ 
// 'key' => [ 
// 'какое-то значение', 
// 'другое значение', 
// ], 
// ]

Вместо того, чтобы переопределить исходное значение под ключом key как это бы сделал array_merge и (. ) или пропустил бы ( + ) — array_merge_recursive создал массив с исходным и новым значением в нем.

Хотя в этом простом примере это выглядит странно, на самом деле это более полезно в тех случаях, когда одно из значений уже является массивом, и вы хотите объединить другой элемент в этом массиве, а не переопределять его:

$first = [ 
'key' => ['какое-то значение'] 
]; 
 
$second = [ 
'key' => 'другое значение' 
];

В этом случае array_merge_recursive возьмет значение из $second массива и добавляет его к значению в $first массиве, который сам уже был массивом:

array_merge_recursive($first, $second); 
 
// [ 
// 'key' => [ 
// 'какое-то значение', 
// 'другое значение', 
// ], 
// ]

Самое важное, что ключ должен иметь одинаковые строковые ключи, если массивы имеют одинаковые числовые ключи, каждое последующее значение не заменит исходное значение, а будет добавлено в конец массива. Рассмотрим более сложный пример:

$first = [ 
42, 
'color' => ['green', 'red', 'blue'] 
]; 
 
$second = [ 
42, 
'color' => 'black' 
]; 
 
$third = [ 
42, 
'color' => [ 
'black' => 1 
] 
]; 
 
$fourth = [ 
'color' => [ 
'black' => [2,3,4] 
], 
42 
]; 
 
array_merge_recursive($first, $second, $third, $fourth); 
 
//Array 
//( 
// [0] => 42 
// [color] => Array 
// ( 
// [0] => green 
// [1] => red 
// [2] => blue 
// [3] => black 
// [black] => Array 
// ( 
// [0] => 1 
// [1] => 2 
// [2] => 3 
// [3] => 4 
// ) 
// 
// ) 
// 
// [1] => 42 
// [2] => 42 
// [3] => 42 
//)

Как можно заметить значения 42 просто добавляется в массив каждый раз, как встречается, ключ color объединил значения цветов, а black так же рекурсивно собрал все значения.

А какие функции в PHP вы бы назвали интересными?
cddolordff

Источник

array_merge

Сливает элементы одного или большего количества массивов таким образом, что значения одного массива присоединяются к концу предыдущего. Результатом работы функции является новый массив.

Если входные массивы имеют одинаковые строковые ключи, тогда каждое последующее значение будет заменять предыдущее. Однако, если массивы имеют одинаковые числовые ключи, значение, упомянутое последним, не заменит исходное значение, а будет добавлено в конец массива.

В результирующем массиве значения исходного массива с числовыми ключами будут перенумерованы в возрастающем порядке, начиная с нуля.

Список параметров

Возвращаемые значения

Возвращает результирующий массив. Если вызывается без аргументов, возвращает пустой массив ( array ).

Список изменений

Версия	Описание
7.4.0	Функция теперь может быть вызвана без каких-либо параметров. Ранее требовался хотя бы один параметр.

Примеры

Пример #1 Пример использования array_merge()

$array1 = array( «color» => «red» , 2 , 4 );
$array2 = array( «a» , «b» , «color» => «green» , «shape» => «trapezoid» , 4 );
$result = array_merge ( $array1 , $array2 );
print_r ( $result );
?>

Результат выполнения данного примера:

Array ( [color] => green [0] => 2 [1] => 4 [2] => a [3] => b [shape] => trapezoid [4] => 4 )

Пример #2 Простой пример использования array_merge()

Помните, что числовые ключи будут перенумерованы!

Если вы хотите дополнить первый массив элементами второго без перезаписи элементов первого массива и без переиндексации, используйте оператор объединения массивов + :

$array1 = array( 0 => ‘zero_a’ , 2 => ‘two_a’ , 3 => ‘three_a’ );
$array2 = array( 1 => ‘one_b’ , 3 => ‘three_b’ , 4 => ‘four_b’ );
$result = $array1 + $array2 ;
var_dump ( $result );
?>

Ключи из первого массива будут сохранены. Если ключ массива существует в обоих массивах, то будет использован элемент из первого массива, а соответствующий элемент из второго массива будет проигнорирован.

array(5) < [0]=>string(6) "zero_a" [2]=> string(5) "two_a" [3]=> string(7) "three_a" [1]=> string(5) "one_b" [4]=> string(6) "four_b" >

Пример #3 Пример использования array_merge() с не массивами

$beginning = ‘foo’ ;
$end = array( 1 => ‘bar’ );
$result = array_merge ((array) $beginning , (array) $end );
print_r ( $result );
?>

Результат выполнения данного примера:

Смотрите также

• array_merge_recursive() — Рекурсивное слияние одного или более массивов
• array_replace() — Заменяет элементы массива элементами других переданных массивов
• array_combine() — Создаёт новый массив, используя один массив в качестве ключей, а другой для его значений
• Операторы, работающие с массивами

User Contributed Notes 8 notes

In some situations, the union operator ( + ) might be more useful to you than array_merge. The array_merge function does not preserve numeric key values. If you need to preserve the numeric keys, then using + will do that.

$array1 [ 0 ] = «zero» ;
$array1 [ 1 ] = «one» ;

$array2 [ 1 ] = «one» ;
$array2 [ 2 ] = «two» ;
$array2 [ 3 ] = «three» ;

$array3 = array( 0 => «zero» , 1 => «one» , 2 => «two» , 3 => «three» );

?>

Note the implicit «array_unique» that gets applied as well. In some situations where your numeric keys matter, this behaviour could be useful, and better than array_merge.

I wished to point out that while other comments state that the spread operator should be faster than array_merge, I have actually found the opposite to be true for normal arrays. This is the case in both PHP 7.4 as well as PHP 8.0. The difference should be negligible for most applications, but I wanted to point this out for accuracy.

Below is the code used to test, along with the results:

for ( $i = 0 ; $i < 10000000 ; $i ++) $array1 = [ 'apple' , 'orange' , 'banana' ];
$array2 = [ ‘carrot’ , ‘lettuce’ , ‘broccoli’ ];

$after = microtime ( true );
echo ( $after — $before ) . » sec for spread\n» ;

for ( $i = 0 ; $i < 10000000 ; $i ++) $array1 = [ 'apple' , 'orange' , 'banana' ];
$array2 = [ ‘carrot’ , ‘lettuce’ , ‘broccoli’ ];

$array1 = array_merge ( $array1 , $array2 );
>

$after = microtime ( true );
echo ( $after — $before ) . » sec for array_merge\n» ;
?>

PHP 7.4:
1.2135608196259 sec for spread
1.1402177810669 sec for array_merge

PHP 8.0:
1.1952061653137 sec for spread
1.099925994873 sec for array_merge

In addition to the text and Julian Egelstaffs comment regarding to keep the keys preserved with the + operator:
When they say «input arrays with numeric keys will be renumbered» they MEAN it. If you think you are smart and put your numbered keys into strings, this won’t help. Strings which contain an integer will also be renumbered! I fell into this trap while merging two arrays with book ISBNs as keys. So let’s have this example:

$test1 [ ’24’ ] = ‘Mary’ ;
$test1 [ ’17’ ] = ‘John’ ;

$test2 [ ’67’ ] = ‘Phil’ ;
$test2 [ ’33’ ] = ‘Brandon’ ;

$result1 = array_merge ( $test1 , $test2 );
var_dump ( $result1 );

$result2 = [. $test1 , . $test2 ]; // mentioned by fsb
var_dump ( $result2 );
?>

You will get both:

Use the + operator or array_replace, this will preserve — somewhat — the keys:

$result1 = array_replace ( $test1 , $test2 );
var_dump ( $result1 );

$result2 = $test1 + $test2 ;
var_dump ( $result2 );
?>

You will get both:

The keys will keep the same, the order will keep the same, but with a little caveat: The keys will be converted to integers.

We no longer need array_merge() as of PHP 7.4.

Not to contradict ChrisM’s test, but I ran their code example and I got very different results for PHP 8.0.

Testing PHP 8.0.14
1.4955070018768 sec for spread
4.4120140075684 sec for array_merge

If you’re trying to merge an array with something that evaluates to NULL, you’ll get unpredictable results:

$c = array_merge ( $a , $b ); // this won’t work
echo «The merged array is:» ;
var_dump ( $c );
?>

Depending on your error setting, you might not even get anything at all.

array(3) [0]=>
string(1) «1»
[1]=>
string(1) «2»
[2]=>
string(1) «4»
>
NULL
PHP Warning: array_merge(): Expected parameter 2 to be an array, null given in /home/gwyneth/stupid-test.php on line 8
The merged array is: NULL

array(3) [0]=>
string(1) «1»
[1]=>
string(1) «2»
[2]=>
string(1) «4»
>
NULL
PHP Fatal error: Uncaught TypeError: array_merge(): Argument #2 must be of type array, null given in /home/gwyneth/stupid-test.php:8
Stack trace:
#0 /home/gwyneth/stupid-test.php(8): array_merge()
#1
thrown in /home/gwyneth/stupid-test.php on line 8

Depending on your display/debug settings, you might not even get anything.

The solution, of course, is to do a quick & dirty test before passing the 2nd argument:

$c = array_merge ( $a , $b ?? []);
echo «The merged array is:» ;
var_dump ( $c );
?>

Which gives the expected result (PHP 7.4 to PHP 8.2):

While it’s perfectly legitimate to merge empty arrays, null is *not* an empty array!

Источник

PHP: функция array_merge_ recursive ()

PHP: рекурсивное объединение двух или более массивов

Функция array_merge_recursive () используется для объединения элементов одного или нескольких массивов. Элементы одного добавляются в конец предыдущего.

Если входные массивы имеют совпадающие строковые ключи, то значения этих ключей объединяются в массив, и это делается рекурсивно, так что, если одно из значений является самим массивом, функция объединит его с соответствующей записью в другой массив тоже.

Если входные массивы содержат цифровые клавиши, более позднее значение будет добавлено вместо переопределения исходного значения.

массив_мердж_рекурсивный (массив_имя1, массив_имя2 . )

название	Описание	Необходимые / Необязательный	Тип
array_name1	Определяет имя массива.	необходимые	массив
array_name2 ..	Определяет имя массива.	Необязательный	массив

Возвращаемое значение:

Тип значения: Массив

 "Physics","Chemistry", "Biology"); $array2=array("Class-XI", "Class-XII", "Roll"=>20); $result=array_merge_recursive($array1, $array2); print_r($result); ?> 

Массив ([Тема] => Физика [0] => Химия [1] => Биология [2] => Класс XI [3] => Класс XII [Roll] => 20)

Практика здесь онлайн:

Предыдущая: массив_карта
Далее: array_merge

Источник