array_count_values
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
(PHP 4 >= 4.3.0, PHP 5)
array_diff_assoc — Computes the difference of arrays with additional index check
Description
array array_diff_assoc
( array $array1
, array $array2
[, array $...
] )
Compares array1 against array2 and returns the difference. Unlike array_diff() the array keys are used in the comparison.
Parameters
- array1
-
The array to compare from
- array2
-
An array to compare against
- ...
-
More arrays to compare against
Return Values
Returns an array containing all the values from array1 that are not present in any of the other arrays.
Examples
Example #1 array_diff_assoc() example
In this example you see the "a" => "green" pair is present in both arrays and thus it is not in the output from the function. Unlike this, the pair 0 => "red" is in the output because in the second argument "red" has key which is 1.
<?php
$array1 = array("a" => "green", "b" => "brown", "c" => "blue", "red");
$array2 = array("a" => "green", "yellow", "red");
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
The above example will output:
Array
(
[b] => brown
[c] => blue
[0] => red
)
Example #2 array_diff_assoc() example
Two values from key => value pairs are considered equal only if (string) $elem1 === (string) $elem2 . In other words a strict check takes place so the string representations must be the same.
<?php
$array1 = array(0, 1, 2);
$array2 = array("00", "01", "2");
$result = array_diff_assoc($array1, $array2);
print_r($result);
?>
The above example will output:
Array
(
[0] => 0
[1] => 1
)
Notes
Note: This function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using, for example, array_diff_assoc($array1[0], $array2[0]);.
See Also
- array_diff() - Computes the difference of arrays
- array_intersect() - Computes the intersection of arrays
- array_intersect_assoc() - Computes the intersection of arrays with additional index check
add a note
User Contributed Notesarray_diff_assoc
55 dot php at imars dot com
17-Mar-2009 01:09
17-Mar-2009 01:09
jrajpu10 at gmail dot com
25-Oct-2008 05:57
25-Oct-2008 05: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-May-2007 11:01
21-May-2007 11: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-Apr-2007 09:14
11-Apr-2007 09: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-Mar-2007 04:33
19-Mar-2007 04: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-May-2006 07:30
30-May-2006 07: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-Jan-2005 03:56
12-Jan-2005 03: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
09-May-2003 07:55
09-May-2003 07: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.