在JavaScript中比较对象的最佳方法是什么？
例子：
var user1 = {name : "nerd", org: "dev"};
var user2 = {name : "nerd", org: "dev"};
var eq = user1 == user2;
alert(eq); // gives false
我知道如果两个对象引用完全相同的对象，那么它们是相等的，但是有没有方法检查它们是否具有相同的属性值？
以下方式对我有效，但这是唯一的可能性吗？
var eq = Object.toJSON(user1) == Object.toJSON(user2);
alert(eq); // gives true
当前回答
以下算法将处理自引用数据结构、数字、字符串、日期，当然还有普通的嵌套javascript对象：
当
根据==，它们完全相等（字符串和数字首先展开，以确保42等于数字（42））或者它们都是日期并且具有相同的值Of（）或者它们都是同一类型且不是空的。。。它们不是对象，每个==都相等（捕获数字/字符串/布尔值）或者，忽略具有未定义值的财产，它们具有相同的财产，所有这些属性都被视为递归等价。
函数文本不认为函数相同。此测试不够，因为函数可能具有不同的闭包。只有当==这样说时，函数才被认为是相等的（但如果您选择这样做，您可以很容易地扩展等效关系）。
避免了循环数据结构可能导致的无限循环。当areEquivalent试图反驳等式并递归到对象的财产中时，它会跟踪需要进行此子比较的对象。如果等式可以被否定，那么对象之间的某些可达属性路径不同，那么必须有一条最短的可达路径，并且该最短可达路径不能包含两条路径中存在的循环；即在递归比较对象时假设相等是可以的。假设存储在属性areEquivalent_Eq_91_2_34中，该属性在使用后被删除，但如果对象图已经包含此类属性，则行为未定义。使用这样的标记属性是必要的，因为javascript不支持使用任意对象作为键的字典。
function unwrapStringOrNumber(obj) {
return (obj instanceof Number || obj instanceof String
? obj.valueOf()
: obj);
}
function areEquivalent(a, b) {
a = unwrapStringOrNumber(a);
b = unwrapStringOrNumber(b);
if (a === b) return true; //e.g. a and b both null
if (a === null || b === null || typeof (a) !== typeof (b)) return false;
if (a instanceof Date)
return b instanceof Date && a.valueOf() === b.valueOf();
if (typeof (a) !== "object")
return a == b; //for boolean, number, string, xml
var newA = (a.areEquivalent_Eq_91_2_34 === undefined),
newB = (b.areEquivalent_Eq_91_2_34 === undefined);
try {
if (newA) a.areEquivalent_Eq_91_2_34 = [];
else if (a.areEquivalent_Eq_91_2_34.some(
function (other) { return other === b; })) return true;
if (newB) b.areEquivalent_Eq_91_2_34 = [];
else if (b.areEquivalent_Eq_91_2_34.some(
function (other) { return other === a; })) return true;
a.areEquivalent_Eq_91_2_34.push(b);
b.areEquivalent_Eq_91_2_34.push(a);
var tmp = {};
for (var prop in a)
if(prop != "areEquivalent_Eq_91_2_34")
tmp[prop] = null;
for (var prop in b)
if (prop != "areEquivalent_Eq_91_2_34")
tmp[prop] = null;
for (var prop in tmp)
if (!areEquivalent(a[prop], b[prop]))
return false;
return true;
} finally {
if (newA) delete a.areEquivalent_Eq_91_2_34;
if (newB) delete b.areEquivalent_Eq_91_2_34;
}
}
其他回答
以下算法将处理自引用数据结构、数字、字符串、日期，当然还有普通的嵌套javascript对象：
当
根据==，它们完全相等（字符串和数字首先展开，以确保42等于数字（42））或者它们都是日期并且具有相同的值Of（）或者它们都是同一类型且不是空的。。。它们不是对象，每个==都相等（捕获数字/字符串/布尔值）或者，忽略具有未定义值的财产，它们具有相同的财产，所有这些属性都被视为递归等价。
函数文本不认为函数相同。此测试不够，因为函数可能具有不同的闭包。只有当==这样说时，函数才被认为是相等的（但如果您选择这样做，您可以很容易地扩展等效关系）。
避免了循环数据结构可能导致的无限循环。当areEquivalent试图反驳等式并递归到对象的财产中时，它会跟踪需要进行此子比较的对象。如果等式可以被否定，那么对象之间的某些可达属性路径不同，那么必须有一条最短的可达路径，并且该最短可达路径不能包含两条路径中存在的循环；即在递归比较对象时假设相等是可以的。假设存储在属性areEquivalent_Eq_91_2_34中，该属性在使用后被删除，但如果对象图已经包含此类属性，则行为未定义。使用这样的标记属性是必要的，因为javascript不支持使用任意对象作为键的字典。
function unwrapStringOrNumber(obj) {
return (obj instanceof Number || obj instanceof String
? obj.valueOf()
: obj);
}
function areEquivalent(a, b) {
a = unwrapStringOrNumber(a);
b = unwrapStringOrNumber(b);
if (a === b) return true; //e.g. a and b both null
if (a === null || b === null || typeof (a) !== typeof (b)) return false;
if (a instanceof Date)
return b instanceof Date && a.valueOf() === b.valueOf();
if (typeof (a) !== "object")
return a == b; //for boolean, number, string, xml
var newA = (a.areEquivalent_Eq_91_2_34 === undefined),
newB = (b.areEquivalent_Eq_91_2_34 === undefined);
try {
if (newA) a.areEquivalent_Eq_91_2_34 = [];
else if (a.areEquivalent_Eq_91_2_34.some(
function (other) { return other === b; })) return true;
if (newB) b.areEquivalent_Eq_91_2_34 = [];
else if (b.areEquivalent_Eq_91_2_34.some(
function (other) { return other === a; })) return true;
a.areEquivalent_Eq_91_2_34.push(b);
b.areEquivalent_Eq_91_2_34.push(a);
var tmp = {};
for (var prop in a)
if(prop != "areEquivalent_Eq_91_2_34")
tmp[prop] = null;
for (var prop in b)
if (prop != "areEquivalent_Eq_91_2_34")
tmp[prop] = null;
for (var prop in tmp)
if (!areEquivalent(a[prop], b[prop]))
return false;
return true;
} finally {
if (newA) delete a.areEquivalent_Eq_91_2_34;
if (newB) delete b.areEquivalent_Eq_91_2_34;
}
}
我为对象比较编写了这段代码，它似乎有效。检查断言：
function countProps(obj) {
var count = 0;
for (k in obj) {
if (obj.hasOwnProperty(k)) {
count++;
}
}
return count;
};
function objectEquals(v1, v2) {
if (typeof(v1) !== typeof(v2)) {
return false;
}
if (typeof(v1) === "function") {
return v1.toString() === v2.toString();
}
if (v1 instanceof Object && v2 instanceof Object) {
if (countProps(v1) !== countProps(v2)) {
return false;
}
var r = true;
for (k in v1) {
r = objectEquals(v1[k], v2[k]);
if (!r) {
return false;
}
}
return true;
} else {
return v1 === v2;
}
}
assert.isTrue(objectEquals(null,null));
assert.isFalse(objectEquals(null,undefined));
assert.isTrue(objectEquals("hi","hi"));
assert.isTrue(objectEquals(5,5));
assert.isFalse(objectEquals(5,10));
assert.isTrue(objectEquals([],[]));
assert.isTrue(objectEquals([1,2],[1,2]));
assert.isFalse(objectEquals([1,2],[2,1]));
assert.isFalse(objectEquals([1,2],[1,2,3]));
assert.isTrue(objectEquals({},{}));
assert.isTrue(objectEquals({a:1,b:2},{a:1,b:2}));
assert.isTrue(objectEquals({a:1,b:2},{b:2,a:1}));
assert.isFalse(objectEquals({a:1,b:2},{a:1,b:3}));
assert.isTrue(objectEquals({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}},{1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}));
assert.isFalse(objectEquals({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}},{1:{name:"mhc",age:28}, 2:{name:"arb",age:27}}));
assert.isTrue(objectEquals(function(x){return x;},function(x){return x;}));
assert.isFalse(objectEquals(function(x){return x;},function(y){return y+2;}));
Utils.compareObjects = function(o1, o2){
for(var p in o1){
if(o1.hasOwnProperty(p)){
if(o1[p] !== o2[p]){
return false;
}
}
}
for(var p in o2){
if(o2.hasOwnProperty(p)){
if(o1[p] !== o2[p]){
return false;
}
}
}
return true;
};
比较ONE-LEVEL对象的简单方法。
如果要显式检查方法，可以使用method.toSource（）或method.toString（）方法。
如果您在没有JSON库的情况下工作，也许这将帮助您：
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
