suche nach in der

array_diff_key> <array_count_values
Last updated: Fri, 18 May 2012

view this page in

array_diff_assoc

(PHP 4 >= 4.3.0, PHP 5)

array_diff_assoc — Berechnet den Unterschied zwischen Arrays mit zusätzlicher Indexprüfung

Beschreibung

array array_diff_assoc ( array $array1 , array $array2 [, array $... ] )

Vergleicht array1 mit array2 und gibt den Unterschied zurück. Im Gegensatz zu array_diff() werden die Schlüssel des Arrays beim Vergleich herangezogen.

Parameter-Liste

array1

Das Array, das verglichen werden soll

array2

Das Array, mit dem verglichen werden soll

...

Weitere Arrays, mit denen vergleichen werden soll

Rückgabewerte

Gibt ein Array zurück, das alle Werte aus array1 enthält, die in keinem der anderen Arrays vorhanden ist.

Beispiele

Beispiel #1 array_diff_assoc()-Beispiel

In diesem Beispiel sieht man, dass das "a" => "gruen"-Paar in beiden Arrays enthalten ist und daher nicht in der Ausgabe der Funktion auftaucht. Andererseits ist das Paar 0 => "rot" in der Ausgabe, weil "red" im zweiten Array den Wert 1 enthält.

<?php
$array1 = array("a" => "gruen", "b" => "braun", "c" => "blau", "rot");
$array2 = array("a" => "gruen", "gelb", "rot");
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Array
(
    [b] => braun
    [c] => blau
    [0] => rot
)

Beispiel #2 array_diff_assoc()-Beispiel

Zwei Werte von Schlüssel => Wert-Paaren werden nur dann als gleich betrachtet, wenn (string) $elem1 === (string) $elem2 gilt. Anders ausgedrückt findet eine strikte Prüfung statt, in der die String-Repräsentationen gleich sein müssen.

<?php
$array1 = array(0, 1, 2);
$array2 = array("00", "01", "2");
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Array
(
    [0] => 0
    [1] => 1
    )

Anmerkungen

Hinweis: Diese Funktion überprüft nur eine Dimension eines n-dimensionalen Arrays. Natürlich kann man tiefere Dimensionen überprüfen, indem man zum Beispiel array_diff_assoc($array1[0], $array2[0]); verwendet.

Siehe auch



add a note add a note User Contributed Notes
array_diff_assoc
cedric at daneel dot net
21-May-2007 03:01
To diff between n-dimensional array, juste use this :

function array_diff_values($tab1, $tab2)
    {
    $result = array();
    foreach($tab1 as $values) if(! in_array($values, $tab2)) $result[] = $values;
    return $result;
    }
contact at pascalopitz dot com
11-Apr-2007 01:14
The direction of the arguments does actually make a difference:

<?
$a = array(
    'x' => 'x',
    'y' => 'y',
    'z' => 'z',
    't' => 't',
);

$b = array(
    'x' => 'x',
    'y' => 'y',
    'z' => 'z',
    't' => 't',
    'g' => 'g',
);

print_r(array_diff_assoc($a, $b));
print_r(array_diff_assoc($b, $a));
?>

echoes:

Array
(
)
Array
(
    [g] => g
)
chinello at gmail dot com
19-Mar-2007 07:33
A small modification for array_diff_assoc_recursive from 'sc1n at yahoo dot com' , to not display any notices if a key don't exist and if error_reporting is set to E_ALL:
<?php
function array_diff_assoc_recursive($array1, $array2)
{
    foreach($array1 as $key => $value)
    {
        if(is_array($value))
        {
              if(!isset($array2[$key]))
              {
                  $difference[$key] = $value;
              }
              elseif(!is_array($array2[$key]))
              {
                  $difference[$key] = $value;
              }
              else
              {
                  $new_diff = array_diff_assoc_recursive($value, $array2[$key]);
                  if($new_diff != FALSE)
                  {
                        $difference[$key] = $new_diff;
                  }
              }
          }
          elseif(!isset($array2[$key]) || $array2[$key] != $value)
          {
              $difference[$key] = $value;
          }
    }
    return !isset($difference) ? 0 : $difference;
}
?>
Alexander Podgorny
30-May-2006 11:30
NOTE: the diff_array also removes all the duplicate values that match to the values in the second array:

<?
    $array1 = array("a","b","c","a","a");
    $array2 = array("a");

    $diff = array_diff($array1,$array2);

    // yields: array("b","c") the duplicate "a" values are removed
?>
benjamin at moonfactory dot co dot jp
12-Jan-2005 06:56
Hi all,
For php versions < 4.3...

<?php
/**
 * array_diff_assoc for version < 4.3
 **/
if (!function_exists('array_diff_assoc'))
{
    function array_diff_assoc($a1, $a2)
    {
        foreach($a1 as $key => $value)
        {
            if(isset($a2[$key]))
            {
                if((string) $value !== (string) $a2[$key])
                {
                     $r[$key] = $value;
                }
            }else
            {
                $r[$key] = $value;
            }
        }
        return $r ;
    }
}

Hope there's no bug,
cheers
?>
aidan at php dot net
09-Jun-2004 03:34
This functionality is now implemented in the PEAR package PHP_Compat.

More information about using this function without upgrading your version of PHP can be found on the below link:

http://pear.php.net/package/PHP_Compat
Michael Johnson
26-Oct-2003 08:20
[jochem at iamjochem dawt com]
Here is a slightly enhanced version of Micheal Johnsons function.
This version accepts arguments in the same way as
array_diff_assoc (i.e. you can pass as many arrays as you want - any
arguments that are not arrays are ignored). If the first argument is not an array you automatically get empty array back:

The point of the function is to return all values in the first array
whose keys (only keys are checked!) are not present in any subsequently passed arrays.

[original post]
array_diff_assoc() requires that both the key and the value pairs match. To match based on keys only, try this function.

<?php
function array_diff_keys()
{
    $args = func_get_args();

    $res = $args[0];
    if(!is_array($res)) {
        return array();
    }

    for($i=1;$i<count($args);$i++) {
        if(!is_array($args[$i])) {
            continue;
        }
        foreach ($args[$i] as $key => $data) {
            unset($res[$key]);
        }
    }
    return $res;
}

// Example
$a = array('a' => '1', 'b' => '2', 'c' => '3');
$b = array('a' => '2', 'b' => '2', 'e' => '4');

// Yields array('a' => '1', 'c' => '3')
// Note that the 'a' index is not removed (as one might expect)
$c = array_diff_assoc($a, $b);

// Yields array('c' => '3')
$d = array_diff_keys($a, $b);
?>
sc1n at yahoo dot com
11-Jul-2003 09:10
[anders dot carlsson at mds dot mdh dot se]
The user contributed array_diff_assoc_recursive function is good except for the original array_diff_assoc always (?) returns an array.

Therefore I propose that $difference is initially set to an empty array (and the array is always returned), and the comparison against FALSE is replaced by count($new_diff). At least that's the modifications I made to run it they way my code expects.

[original post]
The following will recursively do an array_diff_assoc, which will calculate differences on a multi-dimensional level.  (Forgive me if the braces do not line up, the note script did not like my tabs, and gave me trouble on some spaces.)

<?php
function array_diff_assoc_recursive($array1, $array2)
{
     foreach($array1 as $key => $value)
     {
          if(is_array($value))
          {
               if(!is_array($array2[$key]))
               {
                    $difference[$key] = $value;
               }
               else
               {
                    $new_diff = array_diff_assoc_recursive($value, $array2[$key]);
                    if($new_diff != FALSE)
                    {
                         $difference[$key] = $new_diff;
                    }                               
                }
           }
           elseif(!isset($array2[$key]) || $array2[$key] != $value)
           {
                $difference[$key] = $value;
           }
     }
     return !isset($difference) ? 0 : $difference;
}
?>
carl at thep dot lu dot se
09-May-2003 11:55
To unset elements in an array if you know the keys but not the values, you can do:

<?php
$a = array("foo", "bar", "baz", "quux");
$b = array(1, 3); // Elements to get rid of

foreach($b as $e)
  unset($a[$e]);
?>

Of course this makes most sense if $b has many elements or is dynamically generated.
add a note add a note

array_diff_key> <array_count_values
Last updated: Fri, 18 May 2012