在JS中可以使用"=="和"==="來判斷兩個變數是否相等。"=="只判斷兩個變數值是否相等，不判斷型別是否相等，如果"=="兩邊的變數型別不同，則會先進行隱式型別轉換，嘗試將兩個變數都轉換為"=="左邊的型別，再判斷值是否相等。"==="則必須兩個變數的型別和值全都相等才判定為相等。

由於JS中的物件是一個引用型別資料，當使用物件的變數名進行比較時，事實上是在比較兩個變數名在棧記憶體中儲存的對應物件在堆記憶體中的地址，因此只有兩個變數名引用同一個物件的地址時才會判定為相等。

var obj1 = {
    name:"Benjamin",
    sex : "male"
}
 
var obj2 = {
    name:"Benjamin",
    sex : "male"
}
 
var obj3 = obj1;

//Outputs: false
console.log(obj1 == obj2);
 
//Outputs: false
console.log(obj1 === obj2);

//Outputs: true
console.log(obj1 == obj3);
 
//Outputs: true
console.log(obj1 === obj3);
 
//Outputs: false
console.log(obj2 == obj3);
 
//Outputs: false
console.log(obj2 === obj3);
 

通過上面的程式碼可以看出，由於obj1和ob3的指標指向了記憶體中的同一個地址，所以判定相等，而obj1和obj2即使其屬性完全相同，也不會判定為相等，obj2和obj3同理。

當需要判斷兩個物件的屬性是否相等時，需要根據需求考慮以下幾點：

1. 是否只比較物件的可列舉屬性，排除不可列舉屬性
2. 是否只比較物件的自有屬性，排除原型屬性

確定需求之後可以使用下面列出的方法來嘗試建立一個用於實現物件比較的函式：

下面我們嘗試構建一個可用於比較兩個物件自有全部屬性的函式

function isObjectValueEqual(a, b) {

	//如果a和b不是null或undefined且都是物件或陣列才進行判斷
	if (a && b && typeof a === "object" && typeof b === "object") {
    
	    // 獲取兩個物件的自有全部屬性名的陣列
	    var aProps = Object.getOwnPropertyNames(a);
	    var bProps = Object.getOwnPropertyNames(b);
	 
	    // 如果屬性數量不一致則直接判定為不相等
	    if (aProps.length != bProps.length) {
	        return false;
	    }
	     
	    //遍歷a物件全部自有屬性
	    for (var i in aProps) {
	        var propName = aProps[i];
	        
	        //如果屬性是引用型別（陣列，物件），且b也具有該屬性
	        if (b[propName] && typeof a[propName] === "object"){

	        	//則遞迴呼叫isObjectValueEqual函式
	            var isObjPropEqual = isObjectValueEqual(a[propName],b[propName]);
	            if(!isObjPropEqual) {
	                return false;
	            }
	        } else if (typeof a[propName] === "function") {
                
                //注意：並沒有判斷物件方法相等，只是判斷是具有相同方法名
                if ( !b[propName] ){
                    return false;
                } 
            } else if (a[propName] !== b[propName]){  // 如果屬性是值型別

	        	//則直接比較值和型別，注意使用全等判斷，避免隱式型別轉換
		        return false;
	        }
	    }

	    //如果a或b存在空值或不是都是物件或陣列則判定不等
	    return true;
    } else {

    	//如果a或b存在空值或不是都是物件或陣列則判定不等
    	return false;
    }
    
}
 
var obj1 = {
    name:"Benjamin",
    sex : "male",
    desc:{
    	title:'title',
    	content:'content'
    }
};
 
var obj2 = {
    name:"Benjamin",
    sex : "male",
    desc:{
    	title:'title',
    	content:'content'
    }
};

console.log(isObjectValueEqual(obj1, obj2)); // true
 

注意，這個函式只判斷了兩個物件內的全部自有屬性，不包括原型方法，如果需要判斷原型屬性，可以考慮使用for in、原型鏈遞迴等方式來改寫上面的方法，還有一點值得注意的是，這個函式不支援判斷兩個物件的方法，只支援判斷屬性。

下面這個方法是Underscore中isEqual的部分原始碼，實現了更深的物件判斷，可以參考其思路：

// Internal recursive comparison function for `isEqual`.
var eq = function(a, b, aStack, bStack) {
  // Identical objects are equal. `0 === -0`, but they aren't identical.
  // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
  if (a === b) return a !== 0 || 1 / a === 1 / b;
  // A strict comparison is necessary because `null == undefined`.
  if (a == null || b == null)return a === b;
  // Unwrap any wrapped objects.
  if (ainstanceof _) a = a._wrapped;
  if (binstanceof _) b = b._wrapped;
  // Compare `[[Class]]` names.
  var className = toString.call(a);
  if (className !== toString.call(b)) return false;
  switch (className) {
    // Strings, numbers, regular expressions, dates, and booleans are compared by value.
    case '[object RegExp]':
    // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
    case '[object String]':
      // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
      // equivalent to `new String("5")`.
      return '' + a === '' + b;
    case '[object Number]':
      // `NaN`s are equivalent, but non-reflexive.
      // Object(NaN) is equivalent to NaN
      if (+a !== +a) return +b !== +b;
      // An `egal` comparison is performed for other numeric values.
      return +a === 0 ? 1 / +a === 1 / b : +a === +b;
    case '[object Date]':
    case '[object Boolean]':
      // Coerce dates and booleans to numeric primitive values. Dates are compared by their
      // millisecond representations. Note that invalid dates with millisecond representations
      // of `NaN` are not equivalent.
      return +a === +b;
  }
  if (typeof a != 'object' || typeof b != 'object') return false;
  // Assume equality for cyclic structures. The algorithm for detecting cyclic
  // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
  var length = aStack.length;
  while (length--) {
    // Linear search. Performance is inversely proportional to the number of
    // unique nested structures.
    if (aStack[length] === a) return bStack[length] === b;
  }
  // Objects with different constructors are not equivalent, but `Object`s
  // from different frames are.
  var aCtor = a.constructor, bCtor = b.constructor;
  if (
    aCtor !== bCtor &&
    // Handle Object.create(x) cases
    'constructor' in a && 'constructor' in b &&
    !(_.isFunction(aCtor) && aCtor instanceof aCtor &&
      _.isFunction(bCtor) && bCtor instanceof bCtor)
  ) {
    return false;
  }
  // Add the first object to the stack of traversed objects.
  aStack.push(a);
  bStack.push(b);
  var size, result;
  // Recursively compare objects and arrays.
  if (className === '[object Array]') {
    // Compare array lengths to determine if a deep comparison is necessary.
    size = a.length;
    result = size === b.length;
    if (result) {
      // Deep compare the contents, ignoring non-numeric properties.
      while (size--) {
        if (!(result = eq(a[size], b[size], aStack, bStack))) break;
      }
    }
  }else {
    // Deep compare objects.
    var keys = _.keys(a), key;
    size = keys.length;
    // Ensure that both objects contain the same number of properties before comparing deep equality.
    result = _.keys(b).length === size;
    if (result) {
      while (size--) {
        // Deep compare each member
        key = keys[size];
        if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
      }
    }
  }
  // Remove the first object from the stack of traversed objects.
  aStack.pop();
  bStack.pop();
  return result;
};
 
// Perform a deep comparison to check if two objects are equal.
_.isEqual = function(a, b) {
  return eq(a, b, [], []);
}; 

利用前面的思路可以嘗試建立一個用於深度克隆物件的函式：

function deepClone(obj) {

    var newObj = null
	
    //判斷obj不是null、undefined、''、0，且是物件或陣列
	if (obj && typeof obj === "object"){

        // Date物件
        if (obj instanceof Date) {
            newObj = new Date();
            newObj.setTime(obj.getTime());

        // 陣列
        }else if (obj instanceof Array) {
            newObj = [];
            for (var i = 0, len = obj.length; i < len; i++) {
                newObj[i] = deepClone(obj[i]);
            }

        // 其他物件
        }else{
        
            // 建立新物件或陣列
    	    newObj = obj instanceof Array ? [] : {}
    
            //定義屬性描述符拷貝函式
            function descriptor(obj1,obj2,prop,value){

                //獲取目標物件的屬性描述符
                var descriptor1 = Object.getOwnPropertyDescriptor(obj1, prop)
                var descriptor2 = {}

                //將目標物件的屬性描述符的值賦給新物件的屬性
                for(key in descriptor1){
                    if(typeof descriptor1[key] === "function"){
                        descriptor2[key] = descriptor1[key]
                    }else{
                        descriptor2[key] = descriptor1[key]
                    }
                }

                //屬性描述符的value要使用傳進來的值
                descriptor2.value = value
                Object.defineProperty(obj2,prop,descriptor2)

                descriptor1 = null
                descriptor2 = null
            }

            // 獲取物件的自有全部屬性名的陣列
	        let props = Object.getOwnPropertyNames(obj)

	        //遍歷obj物件全部自有屬性
	        for (var i in props) {
	            let propName = props[i];

	            //如果屬性是引用型別（陣列，物件）
	            if (typeof obj[propName] === "object"){

                    //則遞迴呼叫deepClone函式
                    descriptor(obj,newObj,propName,deepClone(obj[propName]))

                // 如果屬性是函式
	            } else if (typeof obj[propName] === "function") {
                
                    //則直接引用
                    descriptor(obj,newObj,propName,obj[propName])
                
                // 如果屬性是值型別
                } else {  

	        	    //則直接賦值
                    descriptor(obj,newObj,propName,obj[propName])
	            }
	        }

            //最後把newObj的原型指向obj的原型
            newObj.__proto__ = obj.__proto__
        
            props = null
         }
    }

     //如果obj為空值或不是物件或陣列則返回null
     return newObj;
}

var obj1 = {
    name:"Benjamin",
    sex : "male",
    desc:{
    	title:'title',
    	content:'content'
    }
};
 
var obj2 = deepClone(obj1);

console.log(obj2); //{name: "Benjamin", sex: "male", desc: {…}}

console.log(isObjectValueEqual(obj1, obj2)); //true

這個函式克隆了引數物件內的全部自有屬性，且屬性描述符也和原物件保持一致，並把原型指向了引數物件的原型，使用直接引用方式獲得引數物件的方法。

原文連結：http://www.zuojj.com/archives/775.html，轉載請註明轉自Benjamin-專注前端開發和使用者體驗