Object comparison in JavaScript

Question

What is the best way to compare Objects in JavaScript?

Example:

var user1 = {name : "nerd", org: "dev"};
var user2 = {name : "nerd", org: "dev"};
var eq = user1 == user2;
alert(eq); // gives false

I know that "Two objects are equal if they refer to the exact same Object", but is there a way to check it another way??

Using this way works for me.....but is it the only possibility?

var eq = Object.toJSON(user1) == Object.toJSON(user2);
alert(eq); // gives true

Answer 1

Certainly not the only way - you could prototype a method (against Object here but I certainly wouldn't suggest using Object for live code) to replicate C#/Java style comparison methods.

Edit, since a general example seems to be expected:

Object.prototype.equals = function(x)
{
    for(p in this)
    {
     switch(typeof(this[p]))
     {
      case 'object':
       if (!this[p].equals(x[p])) { return false }; break;
      case 'function':
       if (typeof(x[p])=='undefined' || (p != 'equals' && this[p].toString() != x[p].toString())) { return false; }; break;
      default:
       if (this[p] != x[p]) { return false; }
     }
    }

    for(p in x)
    {
     if(typeof(this[p])=='undefined') {return false;}
    }

    return true;
}

Note that testing methods with toString() is absolutely not good enough but a method which would be acceptable is very hard because of the problem of whitespace having meaning or not, never mind synonym methods and methods producing the same result with different implementations. And the problems of prototyping against Object in general.

Answer 2

if you want to check for methods explicitly you can use the method.toSource() or method.toString() methods.

Answer 3

theres 2 more bug that will cause an error in the given answer

this is the correct algo:

Object.prototype.equals = function(x)
{

for(p in this)
{
    if(typeof(x[p])=='undefined') {return false;}
}

for(p in this)
{
    if (this[p])
    {
        switch(typeof(this[p]))
        {
                case 'object':
                        if (!this[p].equals(x[p])) { return false }; break;
                case 'function':
                        if (typeof(x[p])=='undefined' || (p != 'equals' && this[p].toString() != x[p].toString())) { return false; }; break;
                default:
                        if (this[p] != x[p]) { return false; }
        }
    }
    else
    {
        if (x[p])
        {
            return false;
        }
    }
}

for(p in x)
{
    if(typeof(this[p])=='undefined') {return false;}
}

return true;
}

Answer 4

been searching for about 2 frustrating hours for something like this. 10x, your code worked great and stopped me from pulling out any more of my hair :)

Answer 5

if you work without the JSON-Lib, maybe this will help ya out:

Object.prototype.equals = function(b) {
 var a = this;
 for(i in a) {  
  if(typeof b[i] == 'undefined') {
   return false;
  }
  if(typeof b[i] == 'object') {
   if(!b[i].equals(a[i])) {
    return false;
   }
  }
  if(b[i] != a[i]) {
   return false;
  }
 }
 for(i in b) {
  if(typeof a[i] == 'undefined') {
   return false;
  }
  if(typeof a[i] == 'object') {
   if(!a[i].equals(b[i])) {
    return false;
   }
  }
  if(a[i] != b[i]) {
   return false;
  }
 } 
 return true;
}

var a = {foo:'bar', bar: {blub:'bla'}};
var b = {foo:'bar', bar: {blub:'blob'}};
alert(a.equals(b)); // alert's a false

Answer 6

We should probably add

if( typeof( this[p] ) != typeof( x[p] ) ) return false;

as the first statement of the first for loop in annakata's code.

Answer 7

I have modified a bit the code above. for me 0 !== false and null !== undefined. If you do not need such strict check remove one "=" sign in "this[p] !== x[p]" inside the code.

Object.prototype.equals = function(x){
    for (var p in this) {
        if(typeof(this[p]) !== typeof(x[p])) return false;
        if((this[p]===null) !== (x[p]===null)) return false;
        switch (typeof(this[p])) {
            case 'undefined':
                if (typeof(x[p]) != 'undefined') return false;
                break;
            case 'object':
                if(this[p]!==null && x[p]!==null && (this[p].constructor.toString() !== x[p].constructor.toString() || !this[p].equals(x[p]))) return false;
                break;
            case 'function':
                if (p != 'equals' && this[p].toString() != x[p].toString()) return false;
                break;
            default:
                if (this[p] !== x[p]) return false;
        }
    }
    return true;
}

Then I have tested it with next objects:

var a = {a: 'text', b:[0,1]};
var b = {a: 'text', b:[0,1]};
var c = {a: 'text', b: 0};
var d = {a: 'text', b: false};
var e = {a: 'text', b:[1,0]};
var f = {a: 'text', b:[1,0], f: function(){ this.f = this.b; }};
var g = {a: 'text', b:[1,0], f: function(){ this.f = this.b; }};
var h = {a: 'text', b:[1,0], f: function(){ this.a = this.b; }};
var i = {
    a: 'text',
    c: {
        b: [1, 0],
        f: function(){
            this.a = this.b;
        }
    }
};
var j = {
    a: 'text',
    c: {
        b: [1, 0],
        f: function(){
            this.a = this.b;
        }
    }
};
var k = {a: 'text', b: null};
var l = {a: 'text', b: undefined};

a==b expected true; returned true

a==c expected false; returned false

c==d expected false; returned false

a==e expected false; returned false

f==g expected true; returned true

h==g expected false; returned false

i==j expected true; returned true

d==k expected false; returned false

k==l expected false; returned false

Answer 8

Testing For Equality In JavaScript

QUnit is using slightly different version.