Checking if two arrays are the same

[Bonesnap]

I'm rather surprised PHP doesn't have a built-in function to check if two arrays are the same and returns a boolean.

My situation is as follows:

I have a webpage where an user can modify a software list for a computer lab. On one side is the master list, and on the other is the current software list. The user can add and remove from the current list then clicks a button to submit it.

In my code I have the script query the database, retrieve the current software list (the original), and put the data into an array. The script then takes the list new list and also puts it into an array.

Originally, I had the script just delete whatever was in the table and just re-insert the records based on the new list, but this is obviously not the "proper" way to do it, so I'm revisiting the script to make it better.

I want to first compare the two arrays to even see if there's a change. If not, then don't do any work and just return a message to the user. Otherwise, I want to compare the original list to the new list. Whatever is on the original but not on the new would be deleted from the database, and whatever is on the new but not on the original would be added.

I've browsed the pages at php.net and tried some of the things people have posted, but nothing seems to compare two arrays 100% accurately. I find it ironic with all the obscure functions PHP has, there isn't one for this. Or is there? Am I just blind?

I've looked into array_diff but it doesn't really do what I want it to (plus it maintains the array's keys which is annoying).

Any help would be appreciated, thank you for your time.

[NogDog]

First, can you define precisely what you consider to be "equal"? Do the array key and value combinations need to be the same, or just the values? Do the arrays need to be in the exact same order (probably more an issue if it's not an associative array)? Anything else you can think of that defines two of these arrays as equal? (Perhaps a simple example or two with just a few array elements would help.)

[NogDog]

PS: Note that the "==" operator may be all you need:

<pre><?php
$one = array(1,2,3);
$two = array(1,2,3);
$three = array(1=>1, 2, 3);
$four = array(3,2,1);
$five = array(2 => 3, 1 => 2, 0 => 1);
var_dump($one == $two);
var_dump($one == $three);
var_dump($one == $four);
var_dump($one == $five);
?></pre>

output:

bool(true)
bool(false)
bool(false)
bool(true)

[nrg_alpha]

Hmm.. If I understand correctly, would this example be along the lines of what you are looking for?

$arrOriginal = array(1,2,3,4,5,7,6); // original list
$arrNew = array(1,4,3,2); // new list

$arrOriginalCount = count($arrOriginal); // get total count of original list
$arrNewCount = count($arrNew); // get total count of new list

// resort keys / values for comparison
sort($arrOriginal);
sort($arrNew);

if($arrOriginalCount == $arrNewCount){
	echo 'No change in comparison of original and new list' . "<br /><br />\n";
} else {
	if($arrOriginalCount < $arrNewCount){ // meaning original list is smaller than new list
		$result = array_diff($arrNew, $arrOriginal);
		foreach ($result as $val) {
			$arrOriginal = array_pad($arrOriginal, ++$arrOriginalCount, $val);
		}
	} else { // meaning original list is larger than new list
		$result = array_diff($arrOriginal, $arrNew);
		foreach($result as $key => $val){
			unset($arrOriginal[$key]); // axe entries from original list
		}
	}
}
echo  'Original List: '.'<pre>'.print_r($arrOriginal, true);
echo 'New List: '.'<pre>'.print_r($arrNew, true);

Granted, regardless to whether this fits the bill or not, I can't shake the nagging feeling this could be improved (not from the standpoint of what it does, but rather from a more condensed, cleaner, simplified code standpoint).

[Weedpacket]

// In original but not in new
$removed = array_diff($original, $new);
// In new but not in original
$added = array_diff($new, $original);

If they're both empty, then there was no change.

[nrg_alpha]

Weedpacket;10910281 wrote:

// In original but not in new
$removed = array_diff($original, $new);
// In new but not in original
$added = array_diff($new, $original);

If they're both empty, then there was no change.

Hmm.. interesting.. never thought of it that way.. so integrating that into my intial effort:

$arrOriginal = array(4,2,3,1); // original list
$arrNew = array(1,2,3,4,6,5,7); // new list
sort($arrOriginal);
sort($arrNew);
$removed = array_diff($arrOriginal, $arrNew);
$added = array_diff($arrNew, $arrOriginal);

if(empty($removed) and empty($added)){
    echo 'No change in comparison of original and new list' . "<br /><br />\n";
} else if(!empty($added)){
	$arrOriginalCount = count($arrOriginal);
    foreach ($added as $val) {
        $arrOriginal = array_pad($arrOriginal, ++$arrOriginalCount, $val);
    }
} else {
    foreach($removed as $key => $val){
        unset($arrOriginal[$key]);
    }
}
echo  'Original List: '.'<pre>'.print_r($arrOriginal, true);
echo 'New List: '.'<pre>'.print_r($arrNew, true);

On a side note, the sort() aspect:

sort($arrOriginal);
sort($arrNew);

Doesn't seem to be necessary as far adding / removing elements.. just that the order of keys / values (if mixed) will remain just that...

[dagon]

Bonesnap;10910260 wrote:

Originally, I had the script just delete whatever was in the table and just re-insert the records based on the new list, but this is obviously not the "proper" way to do it, so I'm revisiting the script to make it better.

I think its a valid method that i use a lot. Proper is a moving target.

[Weedpacket]

nrg_alpha wrote:

so integrating that into my intial effort:

I don't get what the rest of the code is for. The loops are simulating array_merge and array_diff, but I don't see why.

Incidentally, the OP hasn't mentioned if these are associative arrays or numerically-indexed ones (the two lines I gave retain keys). Then again, there's also no mention of whether or not the elements are supposed to be unique, or whether order is significant (I've been assuming the former and allowing for the latter). With all the implied different possible interpretations of what "100% accurately" means if $arr1===$arr2 isn't what is meant, it's no wonder that there is still something left for us programmers to do beyond stringing together pre-built functions.

But still, if you want to see what's different about two arrays, then there's no point checking to see if they're identical. If you checked to see if they were identical and the answer was "no", you'd still have to look for differences. If you'd just looked for differences to begin with you'd have your answer about whether or not they're identical - but you wouldn't need it any more. (This assumes that the job of seeing if two arrays are identical is not a lot cheaper than finding any differences.)

dagon wrote:

I think its a valid method that i use a lot. Proper is a moving target.

I use it quite a bit as well: I already have the data, it sometimes seems silly to fetch it all again just to see if I shouldn't put it back. On the other hand, stored procedures can push all this work onto the database, which tends to be geared towards this sort of thing to begin with.

[Bonesnap]

I apologize guys; I should've been more specific.

The arrays are populated with integers which are just IDs in the table (for the specific piece of software).

As for being exact, just the values themselves need to be the same. I would sort the arrays before comparing them, so order wouldn't be an issue. Length of the array would be a no-brainer since if the lengths are different the arrays are obviously different.

The reason I am revisiting the script to do it "properly" is because there's a logging feature implemented, that's needed to track if someone adds or removes software from a room. It tracks each query so if the user was to remove just one piece of software, and the room had ten applications, then the log would just state they removed the software from the lab and re-added it. It's not very accurate and therefore doesn't serve its purpose.

With the way I want to do it, one can read the log and see specifically which pieces of software were added or removed.

I will give the === a try and see what happens.

[nrg_alpha]

Weedpacket;10910318 wrote:

I don't get what the rest of the code is for. The loops are simulating array_merge and array_diff, but I don't see why.

That statement isn't correct.
How can my loop simulate array_merge when that function simply appends the second array to the first? Clearly, that's not what happens with my code. Nor, conversely, does the second loop simulate array_diff, as that function simply outputs the missing values of the larger array that the smaller one doesn't have. Clearly, this isn't what the code does either.

Weedpacket;10910318 wrote:

Incidentally, the OP hasn't mentioned if these are associative arrays or numerically-indexed ones (the two lines I gave retain keys). Then again, there's also no mention of whether or not the elements are supposed to be unique, or whether order is significant

True enough.. Nog already asked about that. For the purpose of what I was thinking, the contents of the array are irrelevant. They could be indexed, or associative, I was more interested in the underlying principal of comparing and adding / removing. So I kept it simple. If I was on the right track, obviously the OP would use the appropriate arrays in use instead.

Weedpacket;10910318 wrote:

But still, if you want to see what's different about two arrays, then there's no point checking to see if they're identical. If you checked to see if they were identical and the answer was "no", you'd still have to look for differences. If you'd just looked for differences to begin with you'd have your answer about whether or not they're identical - but you wouldn't need it any more. (This assumes that the job of seeing if two arrays are identical is not a lot cheaper than finding any differences.)

Upon reading that, I agree. Thanks for the clarification.

[Weedpacket]

Bonesnap wrote:

I will give the === a try and see what happens.

If you look up the array operators in the manual you'll note that the keys will need to match as well. So sort() and array_values() would be needed on both.

But like I said, you won't get any useful information out of the test anyway. The effort would be better spent finding the differences between the two arrays.

nrg_alpha wrote:

How can my loop simulate array_merge when that function simply appends the second array to the first? Clearly, that's not what happens with my code.

Far as I can make out, it does - it takes each element of the second array in turn, uses [man]array_pad[/man] to specify a new size for the array that is one larger than its current size, then filling the gaps that result with that element.
You're right; array_diff doesn't work like the second loop: your loop removes elements from the first array with keys that appear as keys in the second array regardless of values. It's more like array_diff_key, in other words.

[nrg_alpha]

Weedpacket;10910413 wrote:

Far as I can make out, it does - it takes each element of the second array in turn, uses [man]array_pad[/man] to specify a new size for the array that is one larger than its current size, then filling the gaps that result with that element.

Indeed, that is what is happening in the code. But this should not be confused with array_merge, as it is not the same thing.

If I take the two arrays in my sample and shove them through array_merge (using sort() prior to this just to be able to see things listed in order):

$arrOriginal = array(4,2,3,1); // original list
$arrNew = array(1,2,3,4,6,5,7); // new list
sort($arrOriginal);
sort($arrNew);
$mergeArray = array_merge($arrOriginal, $arrNew);
echo '<pre>'.print_r($mergeArray, true);

Output:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 1
    [5] => 2
    [6] => 3
    [7] => 4
    [8] => 5
    [9] => 6
    [10] => 7
)

For my loop to simulate array_merge, the outcome would be identical (but it isn't).

[Weedpacket]

Yeah, but that first loop isn't doing anything with $arrNew any more; it's using $added instead, which isn't the same thing as $arrNew. Compare the results of your loop with array_merge($arrOriginal, $added); (with and without the sort).

$arrOriginal = array(4,2,3,1); // original list
$arrNew = array(1,2,3,4,6,5,7); // new list
sort($arrOriginal);
sort($arrNew);

$added = array_diff($arrNew, $arrOriginal);

print_r(array_merge($arrOriginal, $added));

$arrOriginalCount = count($arrOriginal);
foreach ($added as $val) {
    $arrOriginal = array_pad($arrOriginal, ++$arrOriginalCount, $val);
}
print_r($arrOriginal);

[nrg_alpha]

Ah, I now see what to you meant. I was assuming that when you mean it was simulating array_merge, that the effect was dealing with merging both $arrOriginal and $arrNew. Now I see that you meant dealing with $arrOriginal and $added - which in hindsight makes sense.

Given that, I do agree with this method (which turns out to be obviously much simpler), and not going through all the array_pad stuff. I understand what you meant now.. I stand corrected.

EDIT - Damn, I hate it when I misconceive things, and damn, I hate it when I'm wrong. That's the cost of learning I suppose.