ActionScript Comparing Arrays

Question

how can i evaluate whether my test array is equal to my static constant DEFAULT_ARRAY? shouldn't my output be returning true?

public class myClass extends Sprite
{
private static const DEFAULT_ARRAY:Array = new Array(1, 2, 3);

public function myClass()
{
var test:Array = new Array(1, 2, 3);
trace (test == DEFAULT_ARRAY);
}

//traces false

Answer 1

found out on another site the way to compare arrays is to convert them to strings, then compare.

trace (test.toString() == DEFAULT_ARRAY.toString());
//traces true

Answer 2

What you're doing there is comparing references, not values. This is because an array is not a value type. A number is a value type, for instance. A number with the value of 3 will always be equal to 3, no matter what references you compare. But a reference type, a block of memory accessed by reference, is just that, a block of memory. If you've got two references to the same block, they'll be considered equal. But again, you're really just comparing the references and not the actual values.

In your case, your conditional would be true if you had the following code:

private static const DEFAULT_ARRAY:Array = new Array(1, 2, 3);

public function myClass()
{
    var test:Array = DEFAULT_ARRAY;
    trace (test == DEFAULT_ARRAY);
}

//traces true

Which rather makes sense, since test is now referencing the same memory as is referenced by the constant. In order to make sure the arrays contain the same values, you need to loop through the array and compare the items:

private static const DEFAULT_ARRAY:Array = new Array(1, 2, 3);

public function myClass()
{
    var test:Array = new Array(1, 2, 3);

    var isEqual:Boolean = true;

    for (var i:int = 0; i < test.length; i++)
    {
        if (test[i] == DEFAULT_ARRAY[i])
            continue;
        else
        {
            isEqual = false;
            break;
        }
    }

    trace (isEqual);
}

//traces true

Hamcrest could be useful in these types of scenarios.

Answer 3

Macke has already pointed out the problem. The == operator will tell you (for reference types such as Array objects) if two variables point to the same object. That's clearly not the case here. You have 2 different objects, that happen to have the same content.

So, what you're probably looking for is a way to compare whether 2 arrays have the same contents. This apparently simple task might be trickier than it seems.

The standard way is using a function like this:

function areEqual(a:Array,b:Array):Boolean {
    if(a.length != b.length) {
        return false;
    }
    var len:int = a.length;
    for(var i:int = 0; i < len; i++) {
        if(a[i] !== b[i]) {
            return false;
        }
    }
    return true;
}

This will work in some (arguably most) cases. But it will fail if the items in any of the arrays have reference type semantics (as opposed to value type semantics). Basically, Numbers (including ints and uints), Strings, Boolean, null and undefined have value type semantics:

Given:

var a:int = 0;
var b:int = 0;

This will hold true:

trace(a == b);

For everything else, comparing with == will only return true if both vars reference the same object:

var a:Object = {data:1};
var b:Object = {data:1};

trace(a == b); // false

But

var a:Object = {data:1};
var b:Object = a;

trace(a == b); // true

So, if your arrays contain objects (or in turn other Arrays), the areEqual will fail in this case:

var arr_1:Array = [{data:1}];
var arr_2:Array = [{data:1}];

trace(areEqual(arr_1,arr_2));

Why? Because the {data:1} object that you stored in arr_1 is different from the {data:1} object stored in arr_2.

I don't think it's possible to create a generic function that checks recursively whether two arrays' contents are equal, because there's no generic way of determinig whether two objects should be considered equal. This really depends on your objects, your domain, etc. I.e. in your app, two objects should be considered equal if they have the same ìd (assuming you have defined an ìd property). As I think this shows, there's no way to know before hand what makes to objects equal.