array_count_values
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.
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 comparision.
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 ouput from the function. Unlike this, the pair 0 => "red" is in the ouput 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]);.
add a note
User Contributed Notesarray_diff_assoc
jrajpu10 at gmail dot com
25-Oct-2008 09:57
25-Oct-2008 09:57
cedric at daneel dot net
21-May-2007 03:01
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
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
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
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
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
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
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
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
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.