PHP Doku:: Ermittelt die Unterschiede zwischen Arrays - function.array-diff.html

Verlauf / Chronik / History: (1) anzeigen

Sie sind hier:
Doku-StartseitePHP-HandbuchFunktionsreferenzVariablen- und typbezogene ErweiterungenArraysArray Funktionenarray_diff

Ein Service von Reinhard Neidl - Webprogrammierung.

Array Funktionen

<<array_diff_ukey

array_fill_keys>>

array_diff

(PHP 4 >= 4.0.1, PHP 5)

array_diffErmittelt die Unterschiede zwischen Arrays

Beschreibung

array array_diff ( array $array1 , array $array2 [, array $ ... ] )

Vergleicht array1 mit array2 und gibt die Unterschiede zurück.

Parameter-Liste

array1

Das Array, das verglichen werden soll

array2

Das Array, mit dem verglichen werden soll

...

Weitere Arrays, mit denen verglichen werden soll

Rückgabewerte

Gibt ein Array mit allen Werten von array1 zurück, die in keinem der anderen Arrays vorhanden sind.

Beispiele

Beispiel #1 array_diff()-Beispiel

<?php
$array1 
= array("a" => "grün""rot""blau""rot");
$array2 = array("b" => "grün""gelb""rot");
$result array_diff($array1$array2);

print_r($result);
?>

Wiederholte Elemente in $array1 werden alle gleich behandelt. Dies wird folgendes ausgeben:

Array
(
    [1] => blau
)

Anmerkungen

Hinweis:

Zwei Elemente werden nur dann als gleich angesehen, wenn (string) $elem1 === (string) $elem2. In Worten: Wenn die String-Repräsentation die gleiche ist.

Hinweis:

Beachten Sie, dass diese Funktion nur eine Dimension eines n-dimensionalen Arrays prüft. Natürlich können Sie tiefere Dimensionen prüfen, indem Sie z.B. array_diff($array1[0], $array2[0]); benutzen.

Siehe auch


47 BenutzerBeiträge:
- Beiträge aktualisieren...
eugeny dot yakimovitch at gmail dot com
30.12.2010 12:17
Note that array_diff is not equivalent to

<?php
function fullArrayDiff($left, $right)
{
    return
array_diff(array_merge($left, $right), array_intersect($left, $right));
}
?>

since it is a set-theoretical complement as in

http://en.wikipedia.org/wiki/Complement_(set_theory)
javierchinapequeno at yahoo dot es
21.12.2010 20:21
Hi, I´d like to give a piece of advice to all who need to use this function to compare two arrays that have a great quantity of elements. You should sort both arrays first before comparing, it will work faster.
Thanks
webmaster at drakkofox dot net
15.10.2010 16:48
If you simply want to verify if a array is different of another one, use IF.

array_diff was returning a empty array when i received values from a form and compared they both(one was from a input type hidden array, and another was from input type checkbox), even if one of they were different. i tried switching places between arr1 and arr2, no good.
thefrox at gmail dot com
30.06.2010 14:28
Multidimensional array_diff

<?php
echo '<pre>';
$bdd['80395']= array('80396','80397','80398','777');
$folder['80395']= array('80396','80397','666','80398','154223');
$folder['80397']= array('34','35','36','45','57');

echo
'<hr>';

function
multidimensional_array_diff($a1,$a2)
{
 
$r = array();
 
 foreach (
$a2 as $key => $second)
 {
      foreach (
$a1 as $key => $first)
      {
             
            if (isset(
$a2[$key]))
            {
                foreach (
$first as $first_value)
                {
                    foreach (
$second as $second_value)
                    {
                        if (
$first_value == $second_value)
                        {
                           
$true = true;
                            break;   
                        }
                    }
                    if (!isset(
$true))
                    {
                       
                       
$r[$key][] = $first_value;
                    }
                    unset(
$true);
                }
            }
            else
            {
               
$r[$key] = $first;
            }
      }
 }
  return
$r;
}
print_r(single_diff_assoc($folder,$bdd));
?>

RESULT :

Array
(
    [80395] => Array
        (
            [0] => 666
            [1] => 154223
        )

    [80397] => Array
        (
            [0] => 34
            [1] => 35
            [2] => 36
            [3] => 45
            [4] => 57
        )

)
S Gower
15.02.2010 23:45
array_diff does not create a new array containing the values present in $array1 but not $array2 -- it simply unsets all of the value in $array1 that are in $array2 and returns it.

This means that the indexes of the returned array are typically not continuous from zero. For example:

<?php

$array1
= array('red', 'blue', 'green', 'octarine');
$array2 = array('red', 'yellow', 'green');
$diff = array_diff($array1, $array2);

print_r($diff); //Array ( [1] => blue [3] => octarine )

?>

The easiest way around this seems to be use array_merge:

<?php

print_r
(array_merge($diff)) //Array ( [0] => blue [1] => octarine )

?>
pikiou at somethinggooglerelated dot com
13.11.2009 13:24
With previous solutions handling multi-dimensional arrays or objects through serialization, if compared variables contain references at some point, these will be serialized and stand as such after the diff function.
Here is a safer solution :
<?php
function array_diff_no_cast(&$ar1, &$ar2) {
  
$diff = Array();
   foreach (
$ar1 as $key => $val1) {
      if (
array_search($val1, $ar2) === false) {
        
$diff[$key] = $val1;
      }
   }
   return
$diff;
}
?>

Example:
<?php
$referenced
= Array(1,1);
$array1 = Array(&$referenced, Array(2,3));
$array2 = Array(Array(1,1), Array(4,5));
$result = array_diff_no_cast($array1, $array2);

print_r($result);   //Outputs Array(1 => Array(2,3))
//And $referenced stands unchanged (not serialized)
?>
vojtech dot hordejcuk at gmail dot com
3.11.2009 16:15
Based on one lad's code, I created following function for creating something like HTML diff. I hope it will be useful.

<?php
private function diff ($old, $new)
{
 
$old = preg_replace ('/ +/', ' ', $old);
 
$new = preg_replace ('/ +/', ' ', $new);
 
 
$lo = explode ("\n", trim ($old) . "\n");
 
$ln = explode ("\n", trim ($new) . "\n");
 
$size = max (count ($lo), count ($ln));

 
$equ = array_intersect ($lo, $ln);
 
$ins = array_diff ($ln, $lo);
 
$del = array_diff ($lo, $ln);
 
 
$out = '';
 
  for (
$i = 0; $i < $size; $i++)
  {
    if (isset (
$del [$i]))
    {
     
$out .= '<p><del>' . $del [$i] . '</del></p>';
    }
   
    if (isset (
$equ [$i]))
    {
     
$out .= '<p>' . $equ [$i] . '</p>';
    }
   
    if (isset (
$ins [$i]))
    {
     
$out .= '<p><ins>' . $ins [$i] . '</ins></p>';
    }
  }
 
  return
$out;
}
?>
Anonymous
15.10.2009 20:55
Hi!
I tried hard to find a solution to a problem I'm going to explain here, and after have read all the array functions and possibilities, I had to create what I think should exist on next PHP releases.

What I needed, it's some kind of Difference, but working with two arrays and modifying them at time, not returning an array as a result with the diference itself.

So, as an example:

A = 1,2,3
B = 2,3,4

should NOT be:

C = 1,4

but:

A = 1
B = 4

so basically, I wanted to delete coincidences on both arrays.

Now, I've some actions to do, and I know wich one I've to do with the values from one array or another.
With the normal DIFF I can't, because if I've an array like C=1,4, I dont know if I've to do the Action_A with 1 or with 4, but I really know that everything in A, will go to the Action_A and everithing in B, will go to Action_B. So same happens with 4, don't know wich action to apply...

So I created this:

<?php
function array_diff_ORG_NEW(&$org, &$new, $type='VALUES'){
    switch(
$type){
        case
'VALUES':
           
$int = array_values(array_intersect($org, $new)); //C = A ^ B
           
$org = array_values(array_diff($org, $int)); //A' = A - C
           
$new= array_values(array_diff($new, $int)); //B' = B - C
           
break;
        case
'KEYS':
           
$int = array_values(array_intersect_key($org, $new)); //C = A ^ B
           
$org = array_values(array_diff_key($org, $int)); //A' = A - C
           
$new= array_values(array_diff_key($new, $int)); //B' = B - C
           
break;
    }
}
?>

This cute, works by reference, and modifies the arrays deleting coincidences on both, and leaving intact the non coincidences.

So a call to this will be somethin' like:

<?php
$original
= array(1,2,3);
$new = array(2,3,4);

array_diff_ORG_NEW($original, $new, 'VALUES');
?>

And HERE, I'll have my arrays as I wanted:

$original = 1
$new = 4

Now, why I use it precisely?

Imagine you've some "Events" and some users you select when create the event, can "see" this event you create. So you "share" the event with some users. Ok?

Imagine you created and Event_A, and shared with users 1,2,3.

Now you want to modify the event, and you decide to modify the users to share it. Imagine you change it to users 2,3,4.

(numbers are users ID).

So you can manage when you are going to modify, to have an array with the IDs in DDBB ($original), and then, have another array with ID's corresponding to the users to share after modifying ($new). Wich ones you've to DELETE from DDBB, and wich ones do you've to INSERT?

If you do a simple difference or somehow, you get somethin' like C=1,4.
You have no clue on wich one you've to insert or delete.

But on this way, you can know it, and that's why:

- What keeps on $original, it's somethin not existing in $new at the beggining. So you know that all what you've inside $original, have to be deleted from DDBB because what you did in the modifying process, it's to unselect those users keeping in $original.
- What keeps on $new, it's something not existing in $original at the beggining. Wich means that in the modifying process you added some new users. And those have to be inserted in DDBB. So, everything keeping inside $new, have to be inserted in the DDBB.

Conclusion:

- Remaining in $original --> delete from DB.
- Remaining in $new --> insert into DB.

And that's all!

I hope you find it useful, and I encourage PHP "makers", to add in a not distant future, somethin' like this one natively, because I'm shure that I'm not the first one needing something like this.

Best regards all,

Light.
firegun at terra dot com dot br
24.06.2009 19:52
Hello guys,

I´ve been looking for a array_diff that works with recursive arrays, I´ve tried the ottodenn at gmail dot com function but to my case it doesn´t worked as expected, so I made my own. I´ve haven´t tested this extensively, but I´ll explain my scenario, and this works great at that case :D

We got 2 arrays like these:

<?php
$aArray1
['marcie'] = array('banana' => 1, 'orange' => 1, 'pasta' => 1);
$aArray1['kenji'] = array('apple' => 1, 'pie' => 1, 'pasta' => 1);

$aArray2['marcie'] = array('banana' => 1, 'orange' => 1);
?>

As array_diff, this function returns all the items that is in aArray1 and IS NOT at aArray2, so the result we should expect is:

<?php
$aDiff
['marcie'] = array('pasta' => 1);
$aDiff['kenji'] = array('apple' => 1, 'pie' => 1, 'pasta' => 1);
?>

Ok, now some comments about this function:
 - Different from the PHP array_diff, this function DON´T uses the === operator, but the ==, so 0 is equal to '0' or false, but this can be changed with no impacts.
 - This function checks the keys of the arrays, array_diff only compares the values.

I realy hopes that this could help some1 as I´ve been helped a lot with some users experiences. (Just please double check if it would work for your case, as I sad I just tested to a scenario like the one I exposed)

<?php
function arrayRecursiveDiff($aArray1, $aArray2) {
   
$aReturn = array();
  
    foreach (
$aArray1 as $mKey => $mValue) {
        if (
array_key_exists($mKey, $aArray2)) {
            if (
is_array($mValue)) {
               
$aRecursiveDiff = arrayRecursiveDiff($mValue, $aArray2[$mKey]);
                if (
count($aRecursiveDiff)) { $aReturn[$mKey] = $aRecursiveDiff; }
            } else {
                if (
$mValue != $aArray2[$mKey]) {
                   
$aReturn[$mKey] = $mValue;
                }
            }
        } else {
           
$aReturn[$mKey] = $mValue;
        }
    }
  
    return
$aReturn;
}
?>
pyerre
12.09.2008 15:20
be careful kids, this function can be tricky
<?php
$tab1
=array(0=>"a");
$tab2=array(0=>"a",1=>"b");

print_r(array_diff($tab1,$tab2));
?>
gives
Array
(
)
Tim Trefren
4.04.2008 18:05
Here's a little wrapper for array_diff - I found myself needing to iterate through the edited array, and I didn't need to original keys for anything.

<?php
function arrayDiff($array1, $array2){
   
# This wrapper for array_diff rekeys the array returned
   
$valid_array = array_diff($array1,$array2);
   
   
# reinstantiate $array1 variable
   
$array1 = array();
   
   
# loop through the validated array and move elements to $array1
    # this is necessary because the array_diff function returns arrays that retain their original keys
   
foreach ($valid_array as $valid){
       
$array1[] = $valid;
        }
    return
$array1;
    }
?>
merlinyoda at dorproject dot net
28.03.2008 19:11
As touched on in kitchin's comment of 19-Jun-2007 03:49 and nilsandre at gmx dot de's comment of 17-Jul-2007 10:45, array_diff's behavior may be counter-intuitive if you aren't thinking in terms of set theory.

array_diff() returns a *mathematical* difference (a.k.a. subtraction) of elements in array A that are in array B and *not* what elements are different between the arrays (i.e. those that elements that are in either A or B but aren't in both A and B).

Drawing one of those Ven diagrams or Euler diagrams may help with visualization...

As far as a function for returning what you may be expecting, here's one:

<?php
function array_xor ($array_a, $array_b) {
   
$union_array = array_merge($array_a, $array_b);
   
$intersect_array = array_intersect($array_a, $array_b);
    return
array_diff($union_array, $intersect_array)
}
?>
radim at badsi dot info
5.09.2007 23:03
array_diff doesn't work with arrays of objects because it compares the string-represantation of the arguments (which is always "Object" for an object).

Here is an easy way to compute the difference of two arrays of objects :

<?php

...

function
array_obj_diff ($array1, $array2) {
   
    foreach (
$array1 as $key => $value) {
       
$array1[$key] = serialize ($value);
    }

    foreach (
$array2 as $key => $value) {
       
$array2[$key] = serialize ($value);
    }
   
   
$array_diff = array_diff ($array1, $array2);
   
    foreach (
$array_diff as $key => $value) {
       
$array_diff[$key] = unserialize ($value);
    }
   
    return
$array_diff;
}

array_obj_diff ($ao1, $ao2);
?>
asdf at asdf dot com
15.08.2007 2:21
Even tough the description of this function's behavior has changed it
does not appear as tough the function's behavior has changed.  Below is some test code and its output:

<?php

    $a
= array('1','2','3','4','5');
   
$b = array('1','a','b','c','d','e');
   
$c = array('2','f','g','h','i','j');
   
   
print_r(array_diff($a, $b, $c));

?>

Array
(
    [2] => 3
    [3] => 4
    [4] => 5
)
nilsandre at gmx dot de
17.07.2007 18:45
Again, the function's description is misleading right now. I sought a function, which (mathematically) computes A - B, or, written differently, A \ B. Or, again in other words, suppose

A := {a1, ..., an} and B:= {a1, b1, ... , bm}

=> array_diff(A,B) = {a2, ..., an}

array_diff(A,B) returns all elements from A, which are not elements of B (= A without B).

You should include this in the documentation more precisely, I think.
mr dot kschan at gmail dot com
13.07.2007 6:16
just comment ... i don't know whether the following implementation of array_diff is having a much better meaning to the function name.

function ary_diff( $ary_1, $ary_2 ) {
  // compare the value of 2 array
  // get differences that in ary_1 but not in ary_2
  // get difference that in ary_2 but not in ary_1
  // return the unique difference between value of 2 array
  $diff = array();

  // get differences that in ary_1 but not in ary_2
  foreach ( $ary_1 as $v1 ) {
    $flag = 0;
    foreach ( $ary_2 as $v2 ) {
      $flag |= ( $v1 == $v2 );
      if ( $flag ) break;
    }
    if ( !$flag ) array_push( $diff, $v1 );
  }

  // get difference that in ary_2 but not in ary_1
  foreach ( $ary_2 as $v2 ) {
    $flag = 0;
    foreach ( $ary_1 as $v1 ) {
      $flag |= ( $v1 == $v2 );
      if ( $flag ) break;
    }
    if ( !$flag && !in_array( $v2, $diff ) ) array_push( $diff, $v2 );
  }

  return $diff;
}

i think array_diff should return the difference between the array independent of the order of passing the parameter.
kitchin
19.06.2007 23:49
Until recently, the description said:
"array_diff() returns an array containing all the values of array1 that are not present in any of the other arguments. Note that keys are preserved."

Now it says:
"Compares array1 against array2 and returns the difference."

Now it's not clear what the optional arguments after the first two do.  Also, the difference is not symmetric in its arguments (that is array_intersect).
gilthans at NOgmailSPAM dot com
13.06.2007 19:11
I needed a function to only remove the element the amount of times he appears in the second array. In other words, if you have Array(1, 1, 2) and Array(1), the return value should be Array(1, 2).
So I built this function right here:

<?php
function array_diff_once(){
    if((
$args = func_num_args()) < 2)
        return
false;
   
$arr1 = func_get_arg(0);
   
$arr2 = func_get_arg(1);
    if(!
is_array($arr1) || !is_array($arr2))
        return
false;
    foreach(
$arr2 as $remove){
        foreach(
$arr1 as $k=>$v){
            if((string)
$v === (string)$remove){ //NOTE: if you need the diff to be STRICT, remove both the '(string)'s
               
unset($arr1[$k]);
                break;
//That's pretty much the only difference from the real array_diff :P
           
}
        }
    }
   
//Handle more than 2 arguments
   
$c = $args;
    while(
$c > 2){
       
$c--;
       
$arr1 = array_diff_once($arr1, func_get_arg($args-$c+1));
    }
    return
$arr1;
}
$arr1 = Array("blue", "four"=>4, "color"=>"red", "blue", "green", "green", "name"=>"jon", "green");
$arr2 = Array("4", "red", "blue", "green");
print_r(array_diff_once($arr1, $arr2));
?>
This prints:
Array ( [1] => blue [3] => green [name] => jon [4] => green )

Note that it removes the elements left to right, opposite to what you might expect; in my case the order of elements had no importance. Fixing that would require a small variation.
tim at php dot user
5.06.2007 5:06
The description is wrong, array_diff() returns an array consisting of all elements in $array1 that are not in $array2. The example shows this.

Thats how it works on my php anyway.
ahigerd at stratitec dot com
1.02.2007 23:30
An earlier comment suggested using array_merge() to reindex the array. While this will work, array_values() is about 30-40% faster and accomplishes the same task.

3.08.2006 21: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
25.07.2006 18: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
8.07.2006 1: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
9.03.2006 22: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
22.01.2006 19: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.01.2006 2: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
6.01.2006 13: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
4.01.2006 12: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
3.01.2006 18: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.12.2005 8: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
6.10.2005 14: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.04.2005 1: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
9.02.2005 19: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.12.2004 9: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.11.2003 2: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.11.2003 1: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);
?>
d dot u dot phpnet at holomind dot de
26.03.2003 20: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
24.03.2003 22: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
25.02.2003 22: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.02.2003 1: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
2.11.2002 10: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
6.08.2002 22: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
9.04.2002 20: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
8.02.2002 21: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
16.10.2001 19: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.07.2001 12: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.
david at audiogalaxy dot com
8.04.2001 13: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.



PHP Powered 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",...)