① 方法一：通過JSON.stringify(obj)來判斷兩個對象轉(zhuǎn)后的字符串是否相等
優(yōu)點：用法簡單，對于順序相同的兩個對象可以快速進行比較得到結(jié)果
缺點：這種方法有限制就是當(dāng)兩個對比的對象中key的順序不是完全相同時會比較出錯
② 方法二：
// 對Object擴展一個方法chargeObjectEqual
Object.prototype.chargeObjectEqual = function(obj){
// 當(dāng)前Object對象
var propsCurr = Object.getOwnPropertyNames(this);
// 要比較的另外一個Object對象
var propsCompare = Object.getOwnPropertyNames(obj);
if (propsCurr.length != propsCompare.length) {
return false;
}
for (var i = 0,max = propsCurr.length; i < max; i++) {
var propName = propsCurr[i];
if (this[propName] !== obj[propName]) {
return false;
}
}
return true;
}
getOwnPropertyNames該方法可以將Object對象的第一層key獲取到并返回一個由第一層key組成的數(shù)組。
優(yōu)點：相對方法一進行了優(yōu)化枉氮，可以應(yīng)對不同順序的Object進行比較愿题，不用擔(dān)心順序不同而對比出錯
缺點：從方法中可以看到只能獲取到第一層的key組成的數(shù)組述呐，當(dāng)對象是復(fù)合對象時無法進行多層對象的比較
③ 方法三：
function deepCompare(x, y) {
var i, l, leftChain, rightChain;
function compare2Objects(x, y) {
var p;
// remember that NaN === NaN returns false
// and isNaN(undefined) returns true
if (isNaN(x) && isNaN(y) && typeof x === 'number' && typeof y === 'number') {
return true;
}
// Compare primitives and functions.
// Check if both arguments link to the same object.
// Especially useful on the step where we compare prototypes
if (x === y) {
return true;
}
// Works in case when functions are created in constructor.
// Comparing dates is a common scenario. Another built-ins?
// We can even handle functions passed across iframes
if ((typeof x === 'function' && typeof y === 'function') ||
(x instanceof Date && y instanceof Date) ||
(x instanceof RegExp && y instanceof RegExp) ||
(x instanceof String && y instanceof String) ||
(x instanceof Number && y instanceof Number)) {
return x.toString() === y.toString();
}
// At last checking prototypes as good as we can
if (!(x instanceof Object && y instanceof Object)) {
return false;
}
if (x.isPrototypeOf(y) || y.isPrototypeOf(x)) {
return false;
}
if (x.constructor !== y.constructor) {
return false;
}
if (x.prototype !== y.prototype) {
return false;
}
// Check for infinitive linking loops
if (leftChain.indexOf(x) > -1 || rightChain.indexOf(y) > -1) {
return false;
}
// Quick checking of one object being a subset of another.
// todo: cache the structure of arguments[0] for performance
for (p in y) {
if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
return false;
} else if (typeof y[p] !== typeof x[p]) {
return false;
}
}
for (p in x) {
if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {
return false;
} else if (typeof y[p] !== typeof x[p]) {
return false;
}
switch (typeof(x[p])) {
case 'object':
case 'function':
leftChain.push(x);
rightChain.push(y);
if (!compare2Objects(x[p], y[p])) {
return false;
}
leftChain.pop();
rightChain.pop();
break;
default:
if (x[p] !== y[p]) {
return false;
}
break;
}
}
return true;
}
if (arguments.length < 1) {
return true; //Die silently? Don't know how to handle such case, please help...
// throw "Need two or more arguments to compare";
}
for (i = 1, l = arguments.length; i < l; i++) {
leftChain = []; //Todo: this can be cached
rightChain = [];
if (!compare2Objects(arguments[0], arguments[i])) {
return false;
}
}
return true;
}
深度對比兩個對象是否完全相等够傍，可以封裝成一個組件方便隨時調(diào)用。
