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",...)
(PHP 4 >= 4.3.0, PHP 5)
array_diff_assoc — Berechnet den Unterschied zwischen Arrays mit zusätzlicher Indexprüfung
Vergleicht array1 mit array2 und gibt den Unterschied zurück. Im Gegensatz zu array_diff() werden die Schlüssel des Arrays beim Vergleich herangezogen.
Das Array, das verglichen werden soll
Das Array, mit dem verglichen werden soll
Weitere Arrays, mit denen vergleichen werden soll
Gibt ein Array zurück, das alle Werte aus array1 enthält, die in keinem der anderen Arrays vorhanden ist.
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
)
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.
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]
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.
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;
}
?>
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
)
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).]
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
?>
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 ;
}
}
?>
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.
Diese Seite bei php.net