Объединение нескольких массивов php
Оператор + возвращает левый массив, к которому был присоединён правый массив. Для ключей, которые существуют в обоих массивах, будут использованы значения из левого массива, а соответствующие им элементы из правого массива будут проигнорированы.
$a = array( «a» => «apple» , «b» => «banana» );
$b = array( «a» => «pear» , «b» => «strawberry» , «c» => «cherry» );
$c = $a + $b ; // Объединение $a и $b
echo «Объединение \$a и \$b: \n» ;
var_dump ( $c );
$c = $b + $a ; // Объединение $b и $a
echo «Объединение \$b и \$a: \n» ;
var_dump ( $c );
$a += $b ; // Объединение $a += $b, это $a и $b
echo «Объединение \$a += \$b: \n» ;
var_dump ( $a );
?>
Объединение $a и $b: array(3) < ["a"]=>string(5) "apple" ["b"]=> string(6) "banana" ["c"]=> string(6) "cherry" > Объединение $b и $a: array(3) < ["a"]=>string(4) "pear" ["b"]=> string(10) "strawberry" ["c"]=> string(6) "cherry" > Объединение $a += $b: array(3) < ["a"]=>string(5) "apple" ["b"]=> string(6) "banana" ["c"]=> string(6) "cherry" >
При сравнении элементы массива считаются идентичными, если совпадает и ключ, и соответствующее ему значение.
Пример #1 Сравнение массивов
$a = array( «apple» , «banana» );
$b = array( 1 => «banana» , «0» => «apple» );
var_dump ( $a == $b ); // bool(true)
var_dump ( $a === $b ); // bool(false)
?>
Смотрите также
User Contributed Notes 14 notes
The union operator did not behave as I thought it would on first glance. It implements a union (of sorts) based on the keys of the array, not on the values.
For instance:
$a = array( ‘one’ , ‘two’ );
$b =array( ‘three’ , ‘four’ , ‘five’ );
//not a union of arrays’ values
echo ‘$a + $b : ‘ ;
print_r ( $a + $b );
//a union of arrays’ values
echo «array_unique(array_merge( $a , $b )):» ;
// cribbed from http://oreilly.com/catalog/progphp/chapter/ch05.html
print_r ( array_unique ( array_merge ( $a , $b )));
?>
//output
$a + $b : Array
(
[0] => one
[1] => two
[2] => five
)
array_unique(array_merge(Array,Array)):Array
(
[0] => one
[1] => two
[2] => three
[3] => four
[4] => five
)
The example may get u into thinking that the identical operator returns true because the key of apple is a string but that is not the case, cause if a string array key is the standart representation of a integer it’s gets a numeral key automaticly.
The identical operator just requires that the keys are in the same order in both arrays:
$a = array ( 0 => «apple» , 1 => «banana» );
$b = array ( 1 => «banana» , 0 => «apple» );
var_dump ( $a === $b ); // prints bool(false) as well
$b = array ( «0» => «apple» , «1» => «banana» );
var_dump ( $a === $b ); // prints bool(true)
?>
Note that + will not renumber numeric array keys. If you have two numeric arrays, and their indices overlap, + will use the first array’s values for each numeric key, adding the 2nd array’s values only where the first doesn’t already have a value for that index. Example:
$a = array(‘red’, ‘orange’);
$b = array(‘yellow’, ‘green’, ‘blue’);
$both = $a + $b;
var_dump($both);
array(3) < [0]=>string(3) «red» [1]=> string(6) «orange» [2]=> string(4) «blue» >
To get a 5-element array, use array_merge.
It should be mentioned that the array union operator functions almost identically to array_replace with the exception that precedence of arguments is reversed.
The reason for the above output is that EVERY array in PHP is an associative one.
Since the 3 elements in $b have the same keys( or numeric indices ) as those in $a, those elements in $b are ignored by the union operator.
[]= pushes an element onto the end of an array, similar to array_push:
$array= array(0=>»Amir»,1=>»needs»);
$array[]= «job»;
print_r($array);
?>
Prints: Array ( [0] => Amir [1] => needs [2] => job )
The note about array comparison by Q1712 is not entirely accurate.
«The identical operator just requires that the keys are in the same order in both arrays:»
This may have been the case in past (I cannot verify it). It requires that the keys are in the same order AND that the values match
$a = array ( 0 => «apple» , 1 => «banana» );
$b = array ( 1 => «banana» , 0 => «apple» );
var_dump ( $a === $b ); // prints bool(false) as well
$b = array ( «0» => «apple» , «1» => «banana» );
var_dump ( $a === $b ); // prints bool(true)
$b = array ( «0» => «apple-1» , «1» => «banana-1» );
var_dump ( $a === $b ); // prints bool(false)
Merge two arrays and retain only unique values.
Append values from second array.
Do not care about keys.
$array2 = [
0 => ‘melon’ ,
1 => ‘orange’ ,
2 => ‘banana’ ,
];
$result = array_keys (
array_flip ( $array1 ) + array_flip ( $array2 )
);
?>
Result:
[
[0] => «apple»,
[1] => «orange»,
[2] => «pear»,
[3] => «melon»,
[4] => «banana»,
>
Simple array arithmetic:
A more compact way of adding or subtracting the elements at identical keys.
function array_add ( $a1 , $a2 ) < // .
// adds the values at identical keys together
$aRes = $a1 ;
foreach ( array_slice ( func_get_args (), 1 ) as $aRay ) foreach ( array_intersect_key ( $aRay , $aRes ) as $key => $val ) $aRes [ $key ] += $val ;
$aRes += $aRay ; >
return $aRes ; >
function array_subtract ( $a1 , $a2 ) < // .
// adds the values at identical keys together
$aRes = $a1 ;
foreach ( array_slice ( func_get_args (), 1 ) as $aRay ) foreach ( array_intersect_key ( $aRay , $aRes ) as $key => $val ) $aRes [ $key ] -= $val ;
foreach ( array_diff_key ( $aRay , $aRes ) as $key => $val ) $aRes [ $key ] = — $val ; >
return $aRes ; >
Example :
$a1 = array( 9 , 8 , 7 );
$a2 = array( 1 => 7 , 6 , 5 );
$a3 = array( 2 => 5 , 4 , 3 );
$aSum = array_add ( $a1 , $a2 , $a3 );
$aDiff = array_subtract ( $a1 , $a2 , $a3 );
// $aSum => [9, 15, 18, 9, 3]// $aDiff => [9, 1, -4, -9, -3]
?>
To make a similar function, array_concatenate(), change only the first of the two ‘+=’ in array_add() to ‘.=’
Csaba Gabor from Vienna
When comparing arrays that have (some or all) element-values that are themselves array, then in PHP5 it seems that == and === are applied recursively — that is
* two arrays satisfy == if they have the same keys, and the values at each key satisfy == for whatever they happen to be (which might be arrays);
* two arrays satisfy === if they have the same keys, and the values at each key satisfy === for whatever (etc.).
Which explains what happens if we compare two arrays of arrays of arrays of.
Likewise, the corresponding inversions for != <> and !==.
I’ve tested this to array-of-array-of-array, which seems fairly convincing. I’ve not tried it in PHP4 or earlier.
Look out use + with array combine.
$arr = array(1, 2, 3);
$int=345;
$arr=$arr+$int;
Of couse,use + to combine array is easy and readable.
But if one of the variable is not array type(like above code) ,that would make a PHP Fatal Error:
PHP Fatal error: Unsupported operand types
Maybe should do check before.
hi just see one more example of union.
$a = array( 1 , 2 , 3 );
$b = array( 1 , 7 , 8 , 9 , 10 );
$c = $a + $b ; // Union of $a and $b
echo «Union of \$a and \$b: \n» ;
//echo $c
print_r ( $c );
?>
//output
Union of $a and $b: Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 9 [4] => 10 )
«The + operator appends the right elements in the array from left, whereas duplicated keys are NOT overwritten»
$a = array(«a» => ‘A’, «b» => ‘B’);
$b = array(«a» => ‘A’, «b» => ‘B’, «c» => ‘C’);
$c = $a + $b // or $b + a is the same output;
//Output for $a + b or $b + a
Array (
[a] => A
[b] => B
[c] => C
)
- Операторы
- Приоритет оператора
- Арифметические операторы
- Оператор присваивания
- Побитовые операторы
- Операторы сравнения
- Оператор управления ошибками
- Операторы исполнения
- Операторы инкремента и декремента
- Логические операторы
- Строковые операторы
- Операторы, работающие с массивами
- Оператор проверки типа
array_merge
Сливает элементы одного или большего количества массивов таким образом, что значения одного массива присоединяются к концу предыдущего. Результатом работы функции является новый массив.
Если входные массивы имеют одинаковые строковые ключи, тогда каждое последующее значение будет заменять предыдущее. Однако, если массивы имеют одинаковые числовые ключи, значение, упомянутое последним, не заменит исходное значение, а будет добавлено в конец массива.
В результирующем массиве значения исходного массива с числовыми ключами будут перенумерованы в возрастающем порядке, начиная с нуля.
Список параметров
Исходный сливаемый массив.
Дополнительные сливаемые массивы.
Возвращаемые значения
Возвращает результирующий массив.
Примеры
Пример #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() — Создает новый массив, используя один массив в качестве ключей, а другой в качестве соответствующих значений
- array operators