PHP Doku:: Berechnet den Unterschied zwischen Arrays mit zusätzlicher Indexprüfung - function.array-diff-assoc.html

Verlauf / Chronik / History: (1) anzeigen

Sie sind hier:
Doku-StartseitePHP-HandbuchFunktionsreferenzVariablen- und typbezogene ErweiterungenArraysArray Funktionenarray_diff_assoc

Ein Service von Reinhard Neidl - Webprogrammierung.

Array Funktionen

<<array_count_values

array_diff_key>>

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(012);
$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


8 BenutzerBeiträge:
- Beiträge aktualisieren...
55 dot php at imars dot com
17.03.2009 16:09
I've worked on array_diff_assoc_recursive() mentioned by chinello at gmail dot com and I think it might be worth mentioning here. I wrote a dozen test cases and it seems to be holding up pretty well.

<?php
// dwarven Differences:
// * Replaced isset() with array_key_exists() to account for keys with null contents

// 55 dot php at imars dot com Differences:
// Key differences:
// * Removed redundant test;
// * Returns false bool on exact match (not zero integer);
// * Use type-precise comparison "!==" instead of loose "!=";
// * Detect when $array2 contains extraneous elements;
// * Returns "before" and "after" instead of only "before" arrays on mismatch.

function array_compare($array1, $array2) {
   
$diff = false;
   
// Left-to-right
   
foreach ($array1 as $key => $value) {
        if (!
array_key_exists($key,$array2)) {
           
$diff[0][$key] = $value;
        } elseif (
is_array($value)) {
             if (!
is_array($array2[$key])) {
                   
$diff[0][$key] = $value;
                   
$diff[1][$key] = $array2[$key];
             } else {
                   
$new = array_compare($value, $array2[$key]);
                    if (
$new !== false) {
                         if (isset(
$new[0])) $diff[0][$key] = $new[0];
                         if (isset(
$new[1])) $diff[1][$key] = $new[1];
                    };
             };
        } elseif (
$array2[$key] !== $value) {
            
$diff[0][$key] = $value;
            
$diff[1][$key] = $array2[$key];
        };
 };
 
// Right-to-left
 
foreach ($array2 as $key => $value) {
        if (!
array_key_exists($key,$array1)) {
            
$diff[1][$key] = $value;
        };
       
// No direct comparsion because matching keys were compared in the
        // left-to-right loop earlier, recursively.
 
};
 return
$diff;
};
?>

Note that to catch small type differences, you need to use var_dump() rather than print_r(). For example:

<?php
first
= Array( 'first' => 'second', 'third' => 'fourth',
 
'fifth' => Array( 'oui' => 'yes', 'non' => 'no' ),
 
'sixth' => Array( 3, 4, 2, 1 )
);
$second = Array( 'first' => 'second', 'third' => 'fourth',
 
'fifth' => Array( 'oui' => 'yes', 'non' => 'no' ),
 
'sixth' => Array( 3, 4, '2', 1 )
);
$diff = array_compare($first, $second);
if (
$diff === false) echo "MATCH\n";
else
var_dump($diff);
?>

The above would immediately show that element "sixth", index 2, is int(2) in $first but string(1)"2" in $second. As per the original function, order for associative arrays does not matter, and of course it does with lists.

[EDIT: Credits to php dot notes at dwarven dot co dot uk]
jrajpu10 at gmail dot com
25.10.2008 21:57
array_diff_assoc can also be used to find the duplicates in an array

<?php
$arr
= array('1','2','3','4','3','2','5');
$uniques = array_unique($arr);
// array_diff will not work here, array_diff_assoc works as it takes the key // in account.
$dups = array_diff_assoc($arr, $uniques);

print_r($dups);
?>

Note: The index of the $dups is not in strict sequential order as expected by C programmer.
cedric at daneel dot net
21.05.2007 15:01
To diff between n-dimensional array, juste use this :

<?php
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.04.2007 13:14
The direction of the arguments does actually make a difference:

<?php
$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.03.2007 7:33
The following will recursively do an array_diff_assoc, which will calculate differences on a multi-dimensional level.  This 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;
}
?>

[NOTE BY danbrown AT php DOT net: This is a combination of efforts from previous notes deleted.  Contributors included (Michael Johnson), (jochem AT iamjochem DAWT com), (sc1n AT yahoo DOT com), and (anders DOT carlsson AT mds DOT mdh DOT se).]
Alexander Podgorny
30.05.2006 23:30
NOTE: the diff_array also removes all the duplicate values that match to the values in the second array:

<?php
    $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.01.2005 6: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 ;
    }
}

?>
carl at thep dot lu dot se
9.05.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.



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