In Javascript, why is [1, 2] == [1, 2] or ({a : 1}) == ({a : 1}) false? [duplicate]

Answer 1

Its because javascript object literals do not share the same pointers. Instead a new pointer gets created for each one. Consider the following example:

>>> ({a : 1}) == ({a : 1})
false

... but ...

>>> obj = ({a : 1});
Object

>>> obj == obj
true

obj is a pointer to the litteral object { a : 1 }. So this works because the pointers are the same when you compare them

Answer 2

{ } and [ ] are the same as new Object and new Array

And new Object != new Object (ditto with Array) because they are new and different objects.

If you want to know whether the content of two arbitary objects is the "same" for some value of same then a quick (but slow) fix is

JSON.parse(o) === JSON.parse(o)

A more elegant solution would be to define an equal function (untested)

var equal = function _equal(a, b) {
  // if `===` or `==` pass then short-circuit
  if (a === b || a == b) { 
    return true;
  }
  // get own properties and prototypes
  var protoA = Object.getPrototypeOf(a), 
      protoB = Object.getPrototypeOf(b),
      keysA = Object.keys(a), 
      keysB = Object.keys(b);

  // if protos not same or number of properties not same then false
  if (keysA.length !== keysB.length || protoA !== protoB) {
    return false;
  }
  // recurse equal check on all values for properties of objects
  return keysA.every(function (key) {
    return _equal(a[key], b[key]);
  });
};

equals example

Warning: writing an equality function that "works" on all inputs is hard, some common gotchas are (null == undefined) === true and (NaN === NaN) === false neither of which I gaurd for in my function.

Nor have I dealt with any cross browser problems, I've just assumed ES5 exists.

Answer 3

You are comparing different objects.

>>> var a = [1,2] var b = [1,2]
>>> a == b
false
>>> a == a
true

If you want to test array equality you might want to use some library or just write the test yourself.

Answer 4

To see what kind of code is necessary to do the deep equality you are talking about, check out Underscore.js's _.isEqual function or QUnit's deepEqual implementation.