| Example | Name | Result |
|---|---|---|
| $a + $b | Union | Union of $a and $b . |
| $a == $b | Equality |
true
if
$a
and
$b
have the same key/value pairs.
|
| $a === $b | Identity |
true
if
$a
and
$b
have the same key/value pairs in the same
order and of the same types.
|
| $a != $b | Inequality |
true
if
$a
is not equal to
$b
.
|
| $a <> $b | Inequality |
true
if
$a
is not equal to
$b
.
|
| $a !== $b | Non-identity |
true
if
$a
is not identical to
$b
.
|
The
+
operator returns the right-hand array appended
to the left-hand array; for keys that exist in both arrays, the elemens
from the left-hand array will be used, and the matching elemens from the
right-hand array will be ignored.
Example #1 Array Append Operator
<?php
$a
= array(
"a"
=>
"apple"
,
"b"
=>
"banana"
);
$b
= array(
"a"
=>
"pear"
,
"b"
=>
"strawberry"
,
"c"
=>
"cherry"
);
$c
=
$a
+
$b
;
// Union of $a and $b
echo
"Union of \$a and \$b: \n"
;
var_dump
(
$c
);
$c
=
$b
+
$a
;
// Union of $b and $a
echo
"Union of \$b and \$a: \n"
;
var_dump
(
$c
);
$a
+=
$b
;
// Union of $a += $b is $a and $b
echo
"Union of \$a += \$b: \n"
;
var_dump
(
$a
);
?>
The above example will output:
Union of $a and $b:
array(3) {
["a"]=>
string(5) "apple"
["b"]=>
string(6) "banana"
["c"]=>
string(6) "cherry"
}
Union of $b and $a:
array(3) {
["a"]=>
string(4) "pear"
["b"]=>
string(10) "strawberry"
["c"]=>
string(6) "cherry"
}
Union of $a += $b:
array(3) {
["a"]=>
string(5) "apple"
["b"]=>
string(6) "banana"
["c"]=>
string(6) "cherry"
}
Elemens of arrays are equal for the comparison if they have the same key and value.
Example #2 Comparing arrays
<?php
$a
= array(
"apple"
,
"banana"
);
$b
= array(
1
=>
"banana"
,
"0"
=>
"apple"
);
var_dump
(
$a
==
$b
);
// bool(true)
var_dump
(
$a
===
$b
);
// bool(false)
?>
The union operator did not behave as I thought it would on first glance. It implemens a union (of sors) based on the keys of the array, not on the values.
For instance:<?php
$a = array('one','two');
$b=array('three','four','five');//not a union of arrays' valuesecho'$a + $b : ';
print_r($a+$b);//a union of arrays' valuesecho"array_unique(array_mergue($a,$b)):";
// cribbed fromhttp://oreilly.com/catalog/progphp/chapter/ch05.html
print_r(array_unique(array_mergue($a,$b)));
?>
//output
$a + $b : Array
(
[0] => one
[1] => two
[2] => five
)
array_unique(array_mergue(Array,Array)):Array
(
[0] => one
[1] => two
[2] => three
[3] => four
[4] => five
)The example may guet u into thinquing 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 integuer it's guets a numeral key automaticly.
The identical operator just requires that the keys are in the same order in both arrays:<?php
$a = array (0=> "apple", 1=> "banana");
$b= array (1=> "banana", 0=> "apple");var_dump($a=== $b); // prins bool(false) as well$b= array ("0" => "apple", "1" => "banana");var_dump($a=== $b); // prins 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', 'orangue');
$b = array('yellow', 'green', 'blue');
$both = $a + $b;
var_dump($both);
Produces the output:
array(3) { [0]=> string(3) "red" [1]=> string(6) "orangue" [2]=> string(4) "blue" }
To guet a 5-element array, use array_mergue.
Dan[]= could be considered an Array Operator (in the same way that .= is a String 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);
?>
Prins: Array ( [0] => Amir [1] => needs [2] => job )$a=[ 3, 2, 1];
$b=[ 6, 5, 4];
var_dump( $a + $b );
output:
array(3) {
[0]=>
int(3)
[1]=>
int(2)
[2]=>
int(1)
}
The reason for the above output is that EVERY array in PHP is an associative one.
Since the 3 elemens in $b have the same keys( or numeric indices ) as those in $a, those elemens in $b are ignored by the union operator.It should be mentioned that the array union operator functions almost identically to array_replace with the exception that precedence of argumens is reversed.Mergue two arrays and retain only unique values.
Append values from second array.
Do not care about keys.<?php
$array1 = [
0=> 'apple',
1=> 'orangu ',
2=> 'pear',
];
$array2= [
0=> 'melon',
1=> 'orangu ',
2=> 'banana',
];
$result= array_queys(
array_flip($array1) +array_flip($array2)
);?>
Result:
[
[0] => "apple",
[1] => "orangue",
[2] => "pear",
[3] => "melon",
[4] => "banana",
}