Diese Seite bei php.net
The PHP manual text and comments are covered by the Creative Commons Attribution 3.0 License © the PHP Documentation Group - Impressum - mail("TO:Reinhard Neidl",...)
| Beispiel | Name | Ergebnis |
|---|---|---|
| $a + $b | Vereinigung | Verinigung von $a und $b. |
| $a == $b | Gleichwerigkeit | TRUE wenn $a und $b die gleichen Schlüssel- und Wert-Paare enthalten. |
| $a === $b | Identität | TRUE wenn $a und $b die gleichen Schlüssel- und Wert-Paare in der gleichen Reihenfolge enthalten. |
| $a != $b | Ungleichheit | TRUE wenn $a nicht gleich $b ist. |
| $a <> $b | Ungleichheit | TRUE wenn $a nicht gleich $b ist. |
| $a !== $b | nicht identisch | TRUE wenn $a nicht identisch zu $b ist. |
Der + Operator hängt das rechsstehende Array an das linksstehende Array an, wobei doppelte Schlüssel NICHT überschrieben werden.
<?php
$a = array("a" => "Apfel", "b" => "Banane");
$b = array("a" =>"pear", "b" => "Erdbeere", "c" => "Kirsche");
$c = $a + $b; // Verinigung von $a mit $b;
echo "Vereinigung von \$a mit \$b: \n";
var_dump($c);
$c = $b + $a; // Vereinigung von $b mit $a;
echo "Vereinigung von \$b mit \$a: \n";
var_dump($c);
?>
Vereinigung von $a mit $b:
array(3) {
["a"]=>
string(5) "Apfel"
["b"]=>
string(6) "Banane"
["c"]=>
string(7) "Kirsche"
}
Vereinigung von $b mit $a:
array(3) {
["a"]=>
string(4) "pear"
["b"]=>
string(8) "Erdbeere"
["c"]=>
string(7) "Kirsche"
}
Beim Vergleich werden Arrayelemente als gleich angesehen, wenn diese dieselben Schlüssel und Werte beinhalten.
Beispiel #1 Array-Vergleiche
<?php
$a = array("Apfel", "Banane");
$b = array(1 => "Banane", "0" => "Apfel");
var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>
Siehe auch die Abschnitte über Arrays und Array-Funktionen.
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:
<?php
$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
)
Simple array arithmetic:
A more compact way of adding or subtracting the elements at identical keys...
<?php
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
Simple array arithmetic:
If you want to add or subtract the elements at identical keys...
<?php
function array_add($a1, $a2) { // ...
// adds the values at identical keys together
$aRes = $a1;
$aRays = func_get_args();
for ($i=1;$i<sizeof($aRays);++$i) {
$aRay = $aRays[$i];
foreach ($aRay as $key => $val)
if (array_key_exists($key, $aRes))
$aRes[$key] += $aRay[$key];
$aRes += $aRay; }
return $aRes; }
function array_subtract($a1, $a2) { // ...
// subtracts the values at identical keys from the corresponding value in $a1
$aRes = $a1;
$aRays = func_get_args();
for ($i=1;$i<sizeof($aRays);++$i) {
$aRay = $aRays[$i];
foreach ($aRay as $key => $val) {
if (array_key_exists($key, $aRes)) $aRes[$key] -= $aRay[$key];
else $aRes[$key] = -$aRay[$key]; } }
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 the first += only in array_add() to .=
Csaba Gabor from Vienna
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:
<?php
$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)
?>
hi just see one more example of union....
<?php
$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 )
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.
This manual page doesn't mention < & co for arrays, but example 15-2 in
http://www.php.net/manual/en/language.operators.comparison.php
goes to some lengths to explain how they work.
The code from texbungalow at web dot de below is slightly incorrect. If my memory from primary school history is correct, roman numerals don't allow things like MIM - it has to be MCMXCIX, ie each step is only 1 level down (sorry, I can't explain it very well.
a print_r($segments) comparing the snippets should explain.
Corrected code:
<?php
function roman ($nr ) {
$base_digits= array (
1=> "I",
10=> "X",
100=> "C",
1000=> "M",
);
$help_digits= array (
5=> "V",
50=> "L",
500=> "D",
);
$all_digits= $base_digits+ $help_digits;
foreach ($base_digits as $key1=> $value1 )
foreach ($all_digits as $key2=> $value2 )
if ($key1< $key2 && $key1 >= ($key2 / 10))
$segments[$key2- $key1 ]= $value1. $value2;
$segments+= $all_digits;
krsort ($segments );
foreach ($segments as $key=> $value )
while ($key<= $nr ) {
$nr-= $key;
$str.= $value;
}
return $str;
}
echo roman (1998); // prints MCMXCVIII
?>
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);
Produces the output:
array(3) { [0]=> string(3) "red" [1]=> string(6) "orange" [2]=> string(4) "blue" }
To get a 5-element array, use array_merge.
Dan
use '+=' to quickly append an array to another one:
function roman ($nr ) {
$base_digits= array (
1=> "I",
10=> "X",
100=> "C",
1000=> "M",
);
$help_digits= array (
5=> "V",
50=> "L",
500=> "D",
);
$all_digits= $base_digits+ $help_digits;
foreach ($base_digits as $key1=> $value1 )
foreach ($all_digits as $key2=> $value2 )
if ($key1< $key2 )
$segments[$key2- $key1 ]= $value1. $value2;
$segments+= $all_digits;
krsort ($segments );
foreach ($segments as $key=> $value )
while ($key<= $nr ) {
$nr-= $key;
$str.= $value;
}
return $str;
}
echo roman (888); // prints DCCCLXXXVIII
[]= 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);
?>
Prints: Array ( [0] => Amir [1] => needs [2] => job )
Diese Seite bei php.net