Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg



PHP : Function Reference : Array Functions : array_diff_assoc

array_diff_assoc

Computes the difference of arrays with additional index check (PHP 4 >= 4.3.0, PHP 5)
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

Example237.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
)


Example238.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]);.

Related Examples ( Source code ) » array_diff_assoc


Code Examples / Notes » array_diff_assoc

michael johnson

[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

[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

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.


cedric

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;
}


aidan

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


contact

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
)


alexander podgorny

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

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
?>


chinello

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;
}
?>


Change Language


Follow Navioo On Twitter
array_change_key_case
array_chunk
array_combine
array_count_values
array_diff_assoc
array_diff_key
array_diff_uassoc
array_diff_ukey
array_diff
array_fill_keys
array_fill
array_filter
array_flip
array_intersect_assoc
array_intersect_key
array_intersect_uassoc
array_intersect_ukey
array_intersect
array_key_exists
array_keys
array_map
array_merge_recursive
array_merge
array_multisort
array_pad
array_pop
array_product
array_push
array_rand
array_reduce
array_reverse
array_search
array_shift
array_slice
array_splice
array_sum
array_udiff_assoc
array_udiff_uassoc
array_udiff
array_uintersect_assoc
array_uintersect_uassoc
array_uintersect
array_unique
array_unshift
array_values
array_walk_recursive
array_walk
array
arsort
asort
compact
count
current
each
end
extract
in_array
key
krsort
ksort
list
natcasesort
natsort
next
pos
prev
range
reset
rsort
shuffle
sizeof
sort
uasort
uksort
usort
eXTReMe Tracker