PHP Doku:: Array-Operatoren - language.operators.array.html

Verlauf / Chronik / History: (1) anzeigen

Sie sind hier:
Doku-StartseitePHP-HandbuchSprachreferenzOperatorenArray-Operatoren

Ein Service von Reinhard Neidl - Webprogrammierung.

Operatoren

<<Zeichenketten-Operatoren

Typ Operatoren>>

Array-Operatoren

Array-Operatoren
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);
?>
Dieses Skript gibt folgendes aus:
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(=> "Banane""0" => "Apfel");

var_dump($a == $b); // bool(true)
var_dump($a === $b); // bool(false)
?>

Siehe auch die Abschnitte über Arrays und Array-Funktionen.


11 BenutzerBeiträge:
- Beiträge aktualisieren...
cb at netalyst dot com
15.10.2008 20:39
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
)
csaba at alum dot mit dot edu
24.06.2008 17:54
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
csaba at alum dot mit dot edu
13.12.2007 10:42
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
Q1712 at online dot ms
21.04.2007 2:54
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)
?>
puneet singh @ value-one dot com
18.01.2006 19:42
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 )
kit dot lester at lycos dot co dot uk
21.08.2005 18:01
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.
kit dot lester at lycos dot co dot uk
21.08.2005 17:44
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.
Peter
29.10.2004 16:57
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
?>
dfranklin at fen dot com
22.04.2004 22:40
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
texbungalow at web dot de
27.04.2003 3:46
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
amirlaher AT yahoo DOT co SPOT uk
10.12.2002 7:41
[]= 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 )



PHP Powered 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",...)