var o1 = {a:1,b:2}, s1 = JSON.stringify(o1),
    o2 = {b:2,a:1}, s2 = JSON.stringify(o2);
console.log(s1 == s2);            //  false
console.log(s1);                  // {"a":1,"b":2}
console.log(s2);                  // {"b":2,"a":1}

Object.equal = function( firstObj, secondObject ){
	var keysFirstObj = Object.keys( firstObj );
	var keysSecondObject = Object.keys( secondObject );
	if ( keysFirstObj.length != keysSecondObject.length ) {
		return false;
	}
	return !keysFirstObj.filter(function( key ){
		if ( typeof firstObj[key] == "object" ||  Array.isArray( firstObj[key] ) ) {
			return !Object.equal(firstObj[key], secondObject[key]);
		} else {
			return firstObj[key] !== secondObject[key];
		}
	}).length;
}
alert(Object.equal({a:[1,2,{b:1}], c: {d:[1,2,3]}},{a:[1,2,{b:1}], c: {d:[1,2,3]}}));

/** сравнить объекты по значению рекурсивно все свойства.
 *@param Object firstObj один из объектов для сравнения
 *@param Object secondObject другой объект для сравнения
 *@return boolean true одинаковы, false - различаются
 *Пр.: Object.equals({a:[1,2,3],b:2}, {b:2,a:[1,2,3]}); //true
 *     Object.equals(null, null); //false
 *     Object.equals(1, 1); //true
 *     Object.equals(1, '1');//true
 *     Object.equals(1, {a:1});//false
 *     Object.equals([1,2], [1,2]);//true
 *     Object.equals(new Date(), new Date())//true
 *     
 *     var d= new Date();
 *     var d2= new Date(d.getTime()+3600000);
 *     Object.equals(d, d2); //false
 *     Object.equals(d, d); //true
 *     Object.equals(d, new Date(d.getTime())); //true
 **/
Object.equals = function( firstObj, secondObject ){
    if ((null==firstObj)||(null==secondObject)) return false; //null сравниваем правильно. Если хоть в одном операнде значит false
    if (('object'!=typeof firstObj) && ('object'!=typeof secondObject))  return firstObj==secondObject;//оба из простых - сравнение простых значений. 
    else if (('object'!=typeof firstObj) || ('object'!=typeof secondObject)) return false;//сравнивается простое значение с объектом - всегда не равны
    //в этой точке только если сравниваем именно объекты (оба)    
    
    //отдельно для дат
    if ((firstObj instanceof Date) && (secondObject instanceof Date)) return firstObj.getTime()==secondObject.getTime(); //исключение для дат. сравним их по микросекундам
    else if ((firstObj instanceof Date) && (secondObject instanceof Date)) return false;//Если дата сравнивается с чем-то ещё -то всегда выдать несоответствие
    
    //далее сравниваем нормальные объекты
    var keysFirstObj = Object.keys( firstObj );
    var keysSecondObject = Object.keys( secondObject );
    if ( keysFirstObj.length != keysSecondObject.length ) {return false;}
    return !keysFirstObj.filter(function( key ){
        if ( typeof firstObj[key] == "object" ||  Array.isArray( firstObj[key] ) ) {
            return !Object.equals(firstObj[key], secondObject[key]);
        } else {
            return firstObj[key] !== secondObject[key];
        }
    }).length;
}

alert(Object.equals({a:[1,2,3],b:2}, {b:2,a:[1,2,3]})); //true
alert(Object.equals(null, null); //false
alert(Object.equals(1, 1); //true
alert(Object.equals(1, '1');//true
alert(Object.equals(1, {a:1});//false
alert(Object.equals([1,2], [1,2]);//true
alert(Object.equals(new Date(), new Date())//true

Object.prototype.valueOf= function(){ return JSON.stringify( this ) }

alert( {a:{b:2}} == {a:{b:2}} )

var obj = {
    a: some_value,
    b: obj
};

(function(a){ //расширение алерта, для вывода нескольких значений(мне так нравится=))
	window.alert = function(){
		a(Array.prototype.slice.call(arguments).join('\n'))
	}
}(window.alert))
 
 
if (!Object.keys) { //Object.keys для ослов(с MDN)
  Object.keys = (function () {
    var hasOwnProperty = Object.prototype.hasOwnProperty,
        hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
        dontEnums = [
          'toString',
          'toLocaleString',
          'valueOf',
          'hasOwnProperty',
          'isPrototypeOf',
          'propertyIsEnumerable',
          'constructor'
        ],
        dontEnumsLength = dontEnums.length
 
    return function (obj) {
      if (typeof obj !== 'object' && typeof obj !== 'function' || obj === null) throw new TypeError('Object.keys called on non-object')
 
      var result = []
 
      for (var prop in obj) {
        if (hasOwnProperty.call(obj, prop)) result.push(prop)
      }
 
      if (hasDontEnumBug) {
        for (var i=0; i < dontEnumsLength; i++) {
          if (hasOwnProperty.call(obj, dontEnums[i])) result.push(dontEnums[i])
        }
      }
      return result
    }
  })()
};



 
Object.equals = function( first, second ){
	
	var cache = []; //кеш обьектов, для избежания рекурсии
	
	function inCache( first, second ){
		var i = cache.length;
		while(i--) if( 
			( cache[i][0] === first || cache[i][0] === second) && (cache[i][1] === second  || cache[i][1] === first ) 
		) return true;
		return false
	}
	
	return function eq(f, s){
		if ( f === s ) return true; //сравниваем обычным образом
		if ( f instanceof Date && s instanceof Date ) return +f === +s; //время
		if ( typeof f !== 'object' || typeof s !== 'object' ) return false; //если хотябы один из аргументов не объект (положительный случай для необъектов рассмотрен выше)
		if( inCache(f, s) ) return true; //есть в кеше
		cache.push( [f , s] ); //кешируем
		
		var keys = Object.keys(f), i = keys.length; //получаем ключи
		if (Object.keys(s).length !== i ) return false; //если количество ключей не совпадает
		while(i--) if( !eq(f[keys[i]], s[keys[i]]) ) return false; //рекурсивный вызов
		
		return true
	}(first, second)
}

alert(
	'Обычные объекты:',
	Object.equals({a:[1,2,3],b:2}, {b:2,a:[1,2,3]}), //true
	Object.equals(null, null), //true
	Object.equals(1, 1), //true
	Object.equals(1, '1'), //false
	Object.equals(1, {a:1}), //false
	Object.equals([1,2], [1,2]), //true
	Object.equals(new Date(), new Date()) //true
)

a = {x:1,c:{r:0}};
b = {x:1,c:{r:0}};
c = {x:1,c:{r:0}};
a.c.r = a;
b.c.r = b;
c.c.r = c;
a.z = b;
b.z = c;
c.z = a;
alert( 
	'Рекурсивные:',
	Object.equals(a, b), //true
	Object.equals(a, c), //true
	Object.equals(c, b), //true
	Object.equals(a, {x:1,c:{r:''}}) //false
)