array_diff

add a note User Contributed Notes

04-Aug-2006 03:30


array_diff provides a handy way of deleting array elements by their value, without having to unset it by key, through a lengthy foreach loop and then having to rekey the array.



<?php



//pass value you wish to delete and the array to delete from

function array_delete( $value, $array)

{

    $array = array_diff( $array, array($value) );

    return $array;

}

?>

Colin
26-Jul-2006 12:44


Undocumented return:  it appears this will return NULL if an error occurs (e.g., an argument is not an array) and is not caught.



<?

@array_diff(NULL, array(1));

@array_diff(array(1), NULL);

@array_diff();

?>



All return NULL.  (Note the "@")

ben dot lancaster at design-ontap dot co dot uk
08-Jul-2006 07:57


One common caveat of this function is that if the arrays match, an empty array is return, not a strict boolean. E.g.:



<?php

$array1 = $array2 = array('a','b','c');



var_dump(array_diff($array1,$array2));

/*

 *Returns:

 * array(0) {

 * }

 */

?>

pavlicic at NOSPAM dot hotmail dot com
10-Mar-2006 05:55


<?php



// first array

$vid_player = $vm->getVideosByPlayer($player);



// second array

$vid_playlist = $vm->getVideosByPlaylist($playlist);



// this will not work...

$vid_player = array_diff($vid_player, $vid_playlist);



// but if you do this first...

$videos = array();

foreach ( $vid_player as $player )

{

    if ( $vid_playlist != null )

    {

        foreach ( $vid_playlist as $video )

        {

            if ( $player->id == $video->id )

                $videos[] = $player;

        }

    }

}



// this will work...

$vid_player = array_diff($vid_player, $videos);



?>

The first array_diff() compares two arrays only to find out that all the objects are unique!

Jappie
23-Jan-2006 02:40


Sorry for the bug in my last comment (probably rightfully removed by the admins).

If you want to compare more than 2 arrays, or don't know how many arrays need to be compared, this is your function:



<?php

# An extention to array_diff:

# It returns an array of all values not present in all arrays given. If '$strict' is true,

# it returns all values not present or not in the same order in all arrays given. The

# arrays to compare must be placed in another array, which is used as argument '$arrays'.

# Returns false if the '$arrays' is invalid.

function array_rdiff ($arrays, $strict = false) {

    # check if argument is valid.

    if (!is_array ($arrays))

        return false;

    foreach ($arrays as $array)

        if (!is_array ($array))

            return false;



    # set working variables

    $diff    = array ();

    $amount  = count ($arrays);

    $needles = array_shift ($arrays);



    # compare

    for ($n = 0; $n < $amount; $n++) {

        for ($m = 0; $needles[$m]; $m++) {

            $found     = true;

            $positions = array ($m);

            foreach ($arrays as $haystack) {

                if (($pos = array_search ($needles[$m], $haystack)) === false)

                    $found = false;

                if ($strict)

                    $positions[] = $pos;

            }

            if (!$found)

                $diff[] = $needle;

            elseif ($strict && (count (array_unique ($positions)) > 1))

                $diff[] = $needle;

        }

        $arrays[] = $needles;

        $needles  = array_shift ($arrays);

    }

    return array_unique ($diff);

}

?>

Simon Riget at paragi.dk
22-Jan-2006 09:27


A simple multidimentional key aware array_diff function.

    

<?php    

function arr_diff($a1,$a2){

  foreach($a1 as $k=>$v){

    unset($dv);

    if(is_int($k)){

      // Compare values

      if(array_search($v,$a2)===false) $dv=$v;

      else if(is_array($v)) $dv=arr_diff($v,$a2[$k]);

      if($dv) $diff[]=$dv;

    }else{

      // Compare noninteger keys

      if(!$a2[$k]) $dv=$v;

      else if(is_array($v)) $dv=arr_diff($v,$a2[$k]);

      if($dv) $diff[$k]=$dv;

    }    

  }

  return $diff;

}

?>



This function meets my immidiate needs but I'm shure it can be improved.

doug at NOSPAM dot thrutch dot co dot uk
06-Jan-2006 08:22


After spending half an hour scratching my head wondering why this function wasn't working I realised I had the arguments the wrong way round!



I needed to remove the contents of $array1 from $array2 so I tried:



<?php

$diff    = array_diff($members1, $members2);

?>



WRONG!! A quick swap around and things worked smoothly...



<?php

$diff    = array_diff($members2, $members1);

?>



Hope this saves someone a bit of bother

air at multi dot fi
04-Jan-2006 07:41


A small thing that caused me trouble today, wich I don't see listed on this page is that array_diff keeps the placing for the uniqe values, and removes the duplicated. This gives us empty fields in the array, wich caused me a lot of trouble. The solutions was simply to use array_merge() around the array_diff.



For example: 

$array1 = array('blue', 'red', 'green');

$array2 = array('red');



array_diff($array1, $array2);



Will give us:

------

Array

(

   [0] => red

   [1] => 

   [2] => green

)



But if we use:



array_merge(array_diff($array1, $array2));



We will get:

------

Array

(

   [0] => red

   [1] => green

)

Viking Coder
04-Jan-2006 01:07


To anybody wanting a double-sided array_diff - mentioned by rudigier at noxx dot at. Remember, array_diff gives you everything in the first array that isn't in the subsequent arrays. 



$array1=array('blue','red','green');

$array2=array('blue','yellow','green');



array_merge(array_diff($array1, $array2),array_diff($array2, $array1));



Result

------

Array

(

    [0] => red

    [1] => yellow

)

white_phoenix at ru dot ru
15-Dec-2005 03:37


To: effectpenguin at antarctida dot ru

Re: interesting effect

<?php

function arraycpy(&$target,&$array)

{

 if (!is_array($target)) {$target = array();}

 foreach($array as $k=>$v) {if ($k != "GLOBALS") {$target[$k] = $v;}}

}

arraycpy($old,$GLOBALS);

// some actions with variables:

$homer = "beer";

arraycpy($new,$GLOBALS);

$diff = array_diff($new,$old);

var_dump($diff);

?>

array(1) {

  ["homer"]=>

  string(4) "beer"

}

Windows NT WPX_NB 5.1 build 2600 PHP/5.0.4

penguin at antarctida dot ru
06-Oct-2005 08:41


Interesting effect...

I just wanted to see, what variables are created and not unset after some actions.

So I write:



<?php

$a_var_GlobalsBefore = $GLOBALS;

?>

...some actions with variables

<?php

$a_var_GlobalsAfter = $GLOBALS;

$a_var_VariablesNotUnset = array_diff ($a_var_GlobalsAfter, $a_var_GlobalsBefore);

?>



...and _ALL_ variables puff up in smoke.



Have no idea what causes this behavior, but found a nice workaround:



<?php

$a_var_GlobalsBefore = array_keys ($GLOBALS);

?>

...some actions with variables

<?php

$a_var_GlobalsAfter = array_keys ($GLOBALS);

$a_var_VariablesNotUnset = array_diff ($a_var_GlobalsAfter, $a_var_GlobalsBefore);

?>



...and the unset variables are here.

rafmav
20-Apr-2005 07:24


Here is a few functions to do a fast diff between two arrays in a few lines.

You can use it with other functions described in the function array_merge : array_merge_replace from an other user, and two functions using it : array_merge_diff and array_merge_diff_reverse.

Note that the keys are preserved!

<?

// returns a two dimensions array with the deleted data

// and the added data

function array_diff_both($new,$old)

{

    $del=array_diff_assoc($old,$new);

    $add=array_diff_assoc($new,$old);

    return $diff=array("del"=>$del, "add"=>$add);

}



// returns a two dimensions array with the equal data,

// deleted data and the added data

function array_diff_all($arr_new,$arr_old)

{

    $arr_equ=array_intersect_assoc($arr_new,$arr_old);

    $arr_del=array_diff_assoc($arr_old,$arr_new);

    $arr_add=array_diff_assoc($arr_new,$arr_old);

    return $diff=array("equ"=>$arr_equ, "del"=>$arr_del, "add"=>$arr_add);

}

?>

rudigier at noxx dot at
10-Feb-2005 02:53


if you don't like the php diff (like me) then take look at my diff functions



if you have two arrays, lets say:



a1 = { blue, red, green }

a2 = { blue, yellow, green }



array_diff just gives me nothing, although there is a difference. instead of an empty array, i needed an array which should contain "red" and "yellow" in this case.



single_diff satisfies my wish.



function single_diff(&$a1,&$a2)

{

  $r = array(); // return

  

  foreach ($a1 as $pl) // payload

  {

    if (! in_array($pl, $a2, true) )

      $r[] = $pl;

  }

  

  foreach ($a2 as $pl) // payload

  {

    if (! in_array($pl, $a1, true) && ! in_array($pl, $r, true) )

      $r[] = $pl;

  }

  return $r;

}



--------------------

this one just keeps the keys of the arrays in mind by comparing the values directly. just in case if there are values, which might occur multiple in one of these arrays.



function single_diff_assoc(&$a1,&$a2)

{

  $r = array(); // return

  

  foreach ($a1 as $k => $pl) // payload

  {

    if (! isset($a2[$k]) || $a2[$k] != $pl)

      $r[$k] = $pl;

  }

  

  foreach ($a2 as $k => $pl) // payload

  {

    if ( (! isset($a1[$k]) || $a1[$k] != $pl ) && ! isset($r[$k]) )

      $r[$k] = $pl;

  }

  return $r;

}



recursion support might be useful, but feel free to modify this functions to your own purposes.

j dot j dot d dot mol at ewi dot tudelft dot nl
31-Dec-2004 04:34


Here is some code to take the difference of two arrays. It allows custom modifications like prefixing with a certain string (as shown) or custom compare functions.



<?php 

 // returns all elements in $all which are not in $used in O(n log n) time.

  // elements from $all are prefixed with $prefix_all.

  // elements from $used are prefixed with $prefix_used.

  function filter_unused( $all, $used, $prefix_all = "", $prefix_used = "" ) {

      $unused = array();



      // prefixes are not needed for sorting

      sort( $all );

      sort( $used );



      $a = 0;

      $u = 0;



      $maxa = sizeof($all)-1;

      $maxu = sizeof($used)-1;



      while( true ) {

          if( $a > $maxa ) {

              // done; rest of $used isn't in $all

              break;

          }

          if( $u > $maxu ) {

              // rest of $all is unused

              for( ; $a <= $maxa; $a++ ) {

                  $unused[] = $all[$a];

              }

              break;

          }



          if( $prefix_all.$all[$a] > $prefix_used.$used[$u] ) {

              // $used[$u] isn't in $all?

              $u++;

              continue;

          }



          if( $prefix_all.$all[$a] == $prefix_used.$used[$u] ) {

              // $all[$a] is used

              $a++;

              $u++;

              continue;

          }



          $unused[] = $all[$a];



          $a++;

      }



      return $unused;

  }

?>

sire at coolquotescollection dot com
26-Nov-2003 09:52


Continuing from r.kirschke's excellent diff function (above), here's a function that will turn the result into nicely formatted HTML:



<?php

echo "<html><body bgcolor=white>";



$oldString = "Once there was a boy named Bart and a girl named Lisa.";

$newString = "Once upon a time there was a girl named Lisa.";



echo "Old String: " . $oldString . "<br>";

echo "New String: " . $newString . "<br>";

echo "Difference: " . diff_to_html($oldString, $newString);

// Returns a nicely formatted html string

function diff_to_html($oldString, $newString)

{

  $a1 = explode(" ", $oldString);

  $a2 = explode(" ", $newString);

  $result = arr_diff($a1, $a2);



  foreach ($result[0] as $num => $foo)

  {

    $source = $result[1][$num];

    $element = $result[0][$num];



    switch ($source)

    {

      case "1":

        $pre = "<font color=red><s>";

        $post = "</s></font>";

        break;

      case "2":

        $pre = "<font color=green>";

        $post = "</font>";

        break;

      case "b":

        $pre = "";

        $post = "";

        break;

    } 

    // VERTICAL OUTPUT:

    // $return .= $num . $pre . " " . $source .

    // " " . $element . $post . "<br>";

    // READABLE OUTPUT:

    $return .= $pre . $element . $post . " ";

  } 

  return $return;

} 



?>

19-Nov-2003 08:54


From the page:


Note:  Please note that this function only checks one dimension of a n-dimensional array. Of course you can check deeper dimensions by using array_diff($array1[0], $array2[0]);





I've found a way to bypass that. I had 2 arrays made of arrays.


I wanted to extract from the first array all the arrays not found in the second array. So I used the serialize() function:





<?php


function my_serialize(&$arr,$pos){


  $arr = serialize($arr);


}





function my_unserialize(&$arr,$pos){


  $arr = unserialize($arr);


}





 //make a copy


$first_array_s = $first_array;


$second_array_s = $second_array;





// serialize all sub-arrays


array_walk($first_array_s,'my_serialize'); 


array_walk($second_array_s,'my_serialize');





// array_diff the serialized versions


$diff = array_diff($first_array_s,$second_array_s);





// unserialize the result


array_walk($diff,'my_unserialize');





// you've got it!


print_r($diff);


?>

ampf at egp dot up dot pt
19-Apr-2003 12:34


What I was needing was a way to diff multidimension arrays by a given key.... I came up with this.





<?php


/*


*  Multidimension array subtract by a sub key.


*


*    $array1 = array(


*      array(


*        "name" => "Foo",


*        "mail" => "foo@moo.net"


*      ),


*      array(


*        "name" => "Bar",


*        "mail" => "bar@bie.com"


*      )


*    );


*


*    $array2 = array(


*      array(


*        "name" => "Foo",


*        "mail" => "foo@moo.net"


*      ),


*      array(


*        "name" => "Xpto",


*        "mail" => "xpto@xp.to"


*      )


*    );


*


*    $result = array_subtract($array1, $array2, "name");


*


*    $result = array(


*      array(


*        "name" => "Bar",


*        "mail" => "bar@bie.com"


*      )


*    );


*


*  Authors:


*    Antonio Fernandes <ampf@egp.up.pt>


*


*/


function array_subtract($array1,$array2,$compareString) {


    if (!is_array($array1) || !is_array($array2) || !$compareString) {


        return false;


    }


    $arrResult = array();


    foreach ($array1 as $arrInsideArray1) {


        foreach ($array2 as $arrInsideArray2) {


            $found=false;


            if ($arrInsideArray1[$compareString]==$arrInsideArray2[$compareString]) {


                $found=true;


                break;


            }


        }


        if (!$found) {


            array_push($arrResult,$arrInsideArray1);


        }


    }


    return $arrResult;


}


?>

d dot u dot phpnet at holomind dot de
27-Mar-2003 03:48


I was not satisfied with the compare-funtions of array_diff() so i wrote a litte diff-clone which compares arrays and shows all different entries. You can easliy change the function formatline() for your needs. 



function arr_diff( $a1, $a2, $show_matches=0); 

...

output: 

1 : 1 : - <head><title>Text</title></head>

1 : 1 : + <head><title>Text2</title></head>

4 : 4 : - code b

4 : 4 : + code a

8 : 8 : - code f



See details on:  (example and source)



http://www.holomind.de/phpnet/diff.php

http://www.holomind.de/phpnet/diff.src.php

r dot kirschke at gmx dot net
25-Mar-2003 05:26


Are you looking for a function which returns an edit script (a set of insert and delete instructions on how to change one array into another)? At least, that's what I hoped to find here, so here's some code based on http://www.cs.arizona.edu/people/gene/PAPERS/diff.ps :





<?php


function diff_rek(&$a1,&$a2,$D,$k,&$vbck)


{


 $x=$vbck[$D][$k]; $y=$x-$k;


 if ($D==0)


 {


  if ($x==0) return array(array(),array());


  else


  return array(array_slice($a1,0,$x),array_fill(0,$x,"b"));


 }


 $x2=$vbck[$D-1][$k+1];


 $y2=$vbck[$D-1][$k-1]-($k-1);


 $xdif=$x-$x2; $ydif=$y-$y2;


 $l=min($x-$x2,$y-$y2);


 $x=$x-$l;


 $y=$y-$l;


 if ($x==$x2)


 {


   $res=diff_rek($a1,$a2,$D-1,$k+1,$vbck);


   array_push($res[0],$a2[$y-1]);


   array_push($res[1],"2");


   if ($l>0)


   {


    $res[0]=array_merge($res[0],array_slice($a2,$y,$l));


    $res[1]=array_merge($res[1],array_fill(0,$l,"b"));


   }


 }


 else


 {


   $res=diff_rek($a1,$a2,$D-1,$k-1,$vbck);


   array_push($res[0],$a1[$x-1]);


   array_push($res[1],"1");


   if ($l>0)


   {


    $res[0]=array_merge($res[0],array_slice($a1,$x,$l));


    $res[1]=array_merge($res[1],array_fill(0,$l,"b"));


   }


 }


 return $res;


}





function arr_diff(&$a1,&$a2)


{


 $max=70;


 $c1=count($a1);


 $c2=count($a2);


 $v[1]=0;


 for ($D=0; $D<=$max; $D++)


 {


   for ($k=-$D; $k<=$D; $k=$k+2)


  {


   if (($k==-$D) || ($k!=$D && $v[$k-1]<$v[$k+1]))


    $x=$v[$k+1];


   else


    $x=$v[$k-1]+1;


   $y=$x-$k;


   while (($x<$c1)&&($y<$c2)&&($a1[$x]==$a2[$y]))


    {


     $x++;


     $y++;


    }


    $v[$k]=$x;


    if (($x>=$c1)&&($y>=$c2))


   {


    $vbck[$D]=$v;


    return diff_rek($a1,$a2,$D,$c1-$c2,$vbck);


   };


  }


  $vbck[$D]=$v;


 };


 return -1;


}


?>





This works on arrays of all elements for which the operator "==" is defined.


arr_dif($a1,$a2) returns an array of two arrays:


$result[0] = array of elements from $a1 and $a2


$result[1] = array of chars - one for each element from $result[0]:


 "1" : The corresponding element is from $a1


 "2" : The corresponding element is from $a2


 "b" : The correspondig element is from both source arrays


The function returns -1, when the number of different elements is greater than $max





Example: 


$a1=array("hello","world");


$a2=array("good","bye","world");


=> arr_diff($a1,$a2) = array(array("hello","good","bye","world"), array("1","2","2","b"));

csaba2000 at yahoo dot com
26-Feb-2003 05:58


<?php


function array_key_diff($ar1, $ar2) {  // , $ar3, $ar4, ...


    // returns copy of array $ar1 with those entries removed


    // whose keys appear as keys in any of the other function args


    $aSubtrahends = array_slice(func_get_args(),1);


    foreach ($ar1 as $key => $val)


        foreach ($aSubtrahends as $aSubtrahend) 


            if (array_key_exists($key, $aSubtrahend))


                unset ($ar1[$key]);


    return $ar1;


}





$a = array("c" => "catty", "b" => "batty", "a" => "aunty", 5 => 4, 2.9 => 7, 11, "n" => "nutty");


$b = array(9, "d" => "ditty", "b" => "bratty", "a" => null, 10, 13);


$c = array_key_diff ($a, $b, array(5 => 6));


?>





$c is then equivalent to array('c' => 'catty', 6 => 11, 'n' => 'nutty')





Csaba Gabor from New York

ds2u at the hotmail dot com
24-Feb-2003 08:22


Yes you can get rid of gaps/missing keys by using:





<?php


$result = array_values(array_diff($array1,$array2));


?>





But to drop the storage of void spaces (actually a line feed) which are irritatingly indexed when reading from files - just use difference:





<?php


$array = array ();


$array[0] = "\n";


$result = array_diff($result,$array);


?>





dst

jg at sto dot com dot au
02-Nov-2002 05:54


I have found an interesting use for array_diff. I remember seing somebody having trouble deleting from an array because it left "holes".



I thought about using array_diff to fix the problem. Try running this code and see what it does:



<?php



for($i=0;$i<4;$i++)

{

print("Deleting item $i from the array<BR>");



$my_array = array("value1","value2","value3","value4");



$my_array = array_diff($my_array,array_slice($my_array,$i,1));



foreach($my_array as $value)print("    -->$value<BR>\n");

}

?>



It seems to work for every member of the array. I'm not sure how efficient it would be on really large arrays, though. 



JG Estiot

drNOSPAMtdiggersSPAMNO at hotmail dot com
07-Aug-2002 04:10


array_diff does not have buggy behavior as described above.  The problem stems from calling array_diff() each time in the loop, therefore regererating a new array with an index always at the beginning EVERY time, so each will always pick the first entry.  This is not buggy, but in fact what you've told the program to do :)  The solution is not as much a solution, but properly instructing the program what to do!



Cheers!

TheoDiggers

arjanz at intermax dot nl
10-Apr-2002 02:53


In PHP 4.0.6 the array_minus_array() as shown above didn't work properly, especially when you use duplicated values:





When I wanted to substract


      'Array(1,1,2,3)'


with


      'Array (1,2,4)'





I wanted as result:





'Array(1,3)'





And not just 'Array (3)' as it would give using array_diff(), or nothing as result using the above array_minus_array function.





This worked for me:





<?php


function array_minus_array($a,$b)  { 


    $c = Array();


    foreach ($a as $key => $val) {           


           $posb = array_search($val,$b);


           if (is_integer($posb)) {


               unset($b[$posb]);               


           } else {


               $c[] = $val;


           }


    }


    return $c;


}


?>

alex at bacan dot cl_remove_this_for_email
09-Feb-2002 04:03


For those who are looking how to substract one array for another:


you cannot use the "-" operator !!!





But you can use this function:


<?php


function array_minus_array($a, $b) {


        $c=array_diff($a,$b);


        $c=array_intersect($c, $a);


        return $c;


}


?>





So, for example:


<?php


$a[]="a";


$a[]="b";


$a[]="c";


$b[]="a";


$c=array_minus_array($a,$b);


var_dump($c);


?>





Prints out:


array(2) {


  [1]=>


  string(1) "b"


  [2]=>


  string(1) "c"


}


which is $a-$b, as we wanted.





PD: you may also do a foreach ... if $a in_array $b ... but this is much more elegant !!!


Credits to A.Atala "mandrake", who knows everything about mathematic.

SeanECoates at !donotspam!yahoo dot ca
17-Oct-2001 01:43


I just came upon a really good use for array_diff(). When reading a dir(opendir;readdir), I _rarely_ want "." or ".." to be in the array of files I'm creating. Here's a simple way to remove them:





<?php


 $someFiles = array();


 $dp = opendir("/some/dir");


 while($someFiles[] = readdir($dp));


 closedir($dp);


 


 $removeDirs = array(".","..");


 $someFiles = array_diff($someFiles, $removeDirs);


 


 foreach($someFiles AS $thisFile) echo $thisFile."\n";


?>





S

caugustin at alcyonis dot nospam dot fr
26-Jul-2001 06:57


In version 4.0.1 to 4.0.4, array_diff() works on array of array, but not anymore in version 4.0.5 and 4.0.6.<br>


According to php team : 


When I wrote array_diff I didn't think of this use. It


worked by accident. array_diff was changed to avoid


some ordering problems. The way it was there was no well


defined ordering. Due to automatic type conversion, you


you would have 3d < 99 <  370 < 3d. This made


array_diff fail, this was fixed by always using string


comparisons. That doesn't work for arrays though.

ylu at enreach dot com
19-May-2001 01:15


To skip empty values, simply use:


$result = array_values(array_diff($array1,$array2));

david at audiogalaxy dot com
08-Apr-2001 07:12


Note that array_diff() considers the type of the array elements when it compares them.





If array_diff() doesn't appear to be working, check your inputs using var_dump() to make sure you're not trying to diff an array of integers with an array of strings.

add a note

array_diff

说明