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

The following is done in Firebug:

>>> [1, 2] == [1, 2]
false

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

I thought Javscript has some rule that says, if an Object or Array has the same references to the same elements, then they are equal?

But even if I say

>>> foo = {a : 1}
Object { a=1}

>>> [foo] == [foo]
false

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

Is there a way to make it so that it can do the element comparison and return true?

Answers:

Answer

{ } 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

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.

Answer

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

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.

Tags

Recent Questions

Top Questions

Home Tags Terms of Service Privacy Policy DMCA Contact Us

©2020 All rights reserved.