我知道这有点老了，但我想添加一个解决方案，我想出了这个问题。 我有一个对象，我想知道它的数据什么时候改变。类似于Object。我所做的是:

function checkObjects(obj,obj2){
   var values = [];
   var keys = [];
   keys = Object.keys(obj);
   keys.forEach(function(key){
      values.push(key);
   });
   var values2 = [];
   var keys2 = [];
   keys2 = Object.keys(obj2);
   keys2.forEach(function(key){
      values2.push(key);
   });
   return (values == values2 && keys == keys2)
}

这里可以复制并创建另一组数组来比较值和键。 这很简单，因为它们现在是数组，如果对象大小不同将返回false。

纯JS方法:我的答案是基于生成一个返回相同值的字符串，无论属性顺序是否相同。设置对象可用于切换大小写和空白是否重要。(为了避免失去焦点，我没有包括那些支持函数，或者我猜应该在任何实用程序集中的isObject。)

这里也没有显示，但为了减少字符串比较时间，如果对象很大，你想加快比较，你也可以散列字符串和比较子字符串;这只适用于非常大的对象(当然也有很小的机会出现错误的相等)。

然后你可以比较genObjStr(obj1) ?= genObjStr(obj2)

function genObjStr(obj, settings) {
// Generate a string that corresponds to an object guarenteed to be the same str even if
// the object have different ordering. The string would largely be used for comparison purposes

var settings = settings||{};
var doStripWhiteSpace = defTrue(settings.doStripWhiteSpace);
var doSetLowerCase = settings.doSetLowerCase||false;

if(isArray(obj)) {
    var vals = [];
    for(var i = 0; i < obj.length; ++i) {
        vals.push(genObjStr(obj[i], settings));
    }
    vals = arraySort(vals);
    return vals.join(`,`);

} else if(isObject(obj)) {

    var keys = Object.keys(obj);
    keys = arraySort(keys);

    var vals = [];
    for(var key of keys) {
        
        var value = obj[key];
        
        value = genObjStr(value, settings);

        if(doStripWhiteSpace) {
            key = removeWhitespace(key);
            var value = removeWhitespace(value);
        };
        if(doSetLowerCase) {
            key = key.toLowerCase();
            value = value.toLowerCase();
        }

        vals.push(value);
    }
    var str = JSON.stringify({keys: keys, vals: vals});
    return str
} else {
    if(doStripWhiteSpace) {
        obj = removeWhitespace(obj);
    };
    if(doSetLowerCase) {
        obj = obj.toLowerCase();
    }
    return obj
}

}

var obj1 = {foo: 123, bar: `Test`};
var obj2 = {bar: `Test`, foo: 123};

console.log(genObjStr(obj1) == genObjStr(obj1))

如果两个对象的所有属性都具有相同的值，并且所有嵌套对象和数组都递归地具有相同的值，那么将它们视为相等是很有用的。我也认为以下两个对象是相等的:

var a = {p1: 1};
var b = {p1: 1, p2: undefined};

类似地，数组可以有“缺失”元素和未定义的元素。我也会同样对待它们:

var c = [1, 2];
var d = [1, 2, undefined];

函数:实现等式定义的函数:

function isEqual(a, b) {
    if (a === b) {
        return true;
    }

    if (generalType(a) != generalType(b)) {
        return false;
    }

    if (a == b) {
        return true;
    }

    if (typeof a != 'object') {
        return false;
    }

    // null != {}
    if (a instanceof Object != b instanceof Object) {
        return false;
    }

    if (a instanceof Date || b instanceof Date) {
        if (a instanceof Date != b instanceof Date ||
            a.getTime() != b.getTime()) {
            return false;
        }
    }

    var allKeys = [].concat(keys(a), keys(b));
    uniqueArray(allKeys);

    for (var i = 0; i < allKeys.length; i++) {
        var prop = allKeys[i];
        if (!isEqual(a[prop], b[prop])) {
            return false;
        }
    }
    return true;
}

源代码(包括辅助函数，generalType和uniqueArray): 这里是单元测试和测试运行器。

你可以使用_。isEqual(obj1, obj2)来自underscore.js库。

这里有一个例子:

var stooge = {name: 'moe', luckyNumbers: [13, 27, 34]};
var clone  = {name: 'moe', luckyNumbers: [13, 27, 34]};
stooge == clone;
=> false
_.isEqual(stooge, clone);
=> true

在这里查看官方文档:http://underscorejs.org/#isEqual

这个问题已经有30多个答案了。我将总结并解释它们(用“我父亲”的比喻)，并添加我建议的解决方案。

你有4+1类解

---

1)使用不完整的简单语句

如果你赶时间，那么99%的正确性都可以。

例如，Pratik Bhalodiya建议的JSON.stringify()或JSON。encode，或. tostring()，或其他方法将对象转换为String，然后逐个字符使用===比较两个String。

然而，缺点是在String中没有Object的全局标准唯一表示。例如:{a: 5, b: 8}和{b: 8和a: 5}是相等的。

优点:快，快。 缺点:希望有效!如果环境/浏览器/引擎记住了对象的顺序(例如Chrome/V8)，并且键的顺序不同(感谢Eksapsy)，它将无法工作。所以，完全不能保证。在大型对象中，性能也不会很好。

我的父亲类比

当我在谈论我的父亲时，“我高大英俊的父亲”和“我高大英俊的父亲”是同一个人!但这两个弦是不一样的。

请注意，在英语语法中，形容词的顺序其实是正确的(标准的方式)，它应该是“英俊的高个子男人”，但如果你盲目地认为iOS 8 Safari的Javascript引擎也遵循同样的语法，你就是在拿自己的能力冒险!# WelcomeToJavascriptNonStandards

---

2)自己DIY编写递归函数

如果你正在学习，这很好。

例子是atmin的解。

最大的缺点是你肯定会错过一些边缘情况。您考虑过对象值中的自引用吗?你考虑过NaN吗?您是否考虑过具有相同ownProperties但不同原型父对象的两个对象?

我只鼓励人们在进行实践并且代码不会投入生产的情况下这样做。这是唯一一种重新发明轮子有正当理由的情况。

优点:学习机会。 缺点:不可靠。需要时间和精力。

我的父亲类比

这就像假设我爸爸的名字是“约翰·史密斯”，他的生日是“1/1/1970”，那么任何一个名字是“约翰·史密斯”，出生在“1/1/1970”的人就是我的父亲。

通常情况下是这样，但如果有两个“约翰·史密斯”在那一天出生呢?如果你认为你会考虑他们的身高，那么这就提高了准确性，但仍然不是一个完美的比较。

2.1你的范围有限DIY比较器

与其疯狂地递归检查所有属性，不如考虑只检查“有限”数量的属性。例如，如果对象是Users，您可以比较它们的emailAddress字段。

它仍然不是一个完美的解决方案，但比解决方案#2的好处是:

它是可预测的，而且不太可能崩溃。 您正在推动平等的“定义”，而不是依赖于对象的原始形式和形状及其原型和嵌套属性。

---

3)使用功能相同的图书馆版本

如果您需要生产级别的质量，并且您不能更改系统的设计，则很好。

例如_。等于lodash，已经在coolaj86的回答中，或者在Tony Harvey的回答中提到的Angular的回答中，或者在Node的Rafael Xavier的回答中。

优点:其他人都这么做。 缺点:外部依赖，这可能会花费你额外的内存/CPU/安全问题，甚至一点点。此外，仍然可以错过一些边缘情况(例如，是否两个对象具有相同的ownProperties但不同的原型父应该被认为是相同的。)最后，你可能无意中解决了一个潜在的设计问题;只是说!

我的父亲类比

这就像付钱给中介机构，根据他的电话、姓名、地址等找到我的生父。

这会花更多的钱，而且可能比我做背景调查更准确，但不能涵盖边缘情况，比如我父亲是移民/庇护者，他的生日是未知的!

---

4)在对象中使用标识符

如果你仍然可以改变系统(你正在处理的对象)的设计，并且你希望你的代码能够持久，那就太好了。

它并不适用于所有情况，而且性能可能不太好。然而，这是一个非常可靠的解决方案，如果你能做到的话。

解决方案是，系统中的每个对象都有一个唯一的标识符以及所有其他属性。标识符的唯一性将在生成时得到保证。在比较两个对象时，您将使用这个ID(也称为UUID/GUID—全局/通用唯一标识符)。即，当且仅当这些id相等时，它们相等。

id可以是简单的自动增量数字，也可以是通过库生成的字符串(建议)或一段代码。所有你需要做的是确保它总是唯一的，在auto_incremental的情况下，它可以是内置的，或者在UUID的情况下，可以检查是否所有现有的值(例如MySQL的unique列属性)或简单地(如果来自库)依赖于给出极低的冲突可能性。

注意，您还需要始终将ID存储在对象中(以保证其唯一性)，并且实时计算它可能不是最好的方法。

优点:可靠，高效，不脏，现代。 缺点:需要额外的空间。可能需要重新设计一下系统。

我的父亲类比

我父亲的社保号是911-345-9283，所以有这个社保号的人就是我父亲，任何自称是我父亲的人也一定有这个社保号。

---

结论

就准确性和可靠性而言，我个人更喜欢解决方案#4 (ID)。如果不可能，我会选择2.1，因为它具有可预测性，然后是3。如果两者都不可能，选择第二条，最后是第一条。

这里有一个非常基本的方法来检查对象的“值是否相等”。

var john = {
    occupation: "Web Developer",
    age: 25
};

var bobby = {
    occupation: "Web Developer",
    age: 25
};

function isEquivalent(a, b) {
    // Create arrays of property names

    var aProps = Object.getOwnPropertyNames(a);
    var bProps = Object.getOwnPropertyNames(b);

    // If number of properties is different, objects are not equivalent

    if (aProps.length != bProps.length) {
        return false;
    }

    for (var i = 0; i < aProps.length; i++) {
        var propName = aProps[i];

        // If values of same property are not equal, objects are not equivalent
        if (a[propName] !== b[propName]) {
           return false;
        }
    }

    // If we made it this far, objects are considered equivalent
    return true;
}

// Outputs: true
console.log(isEquivalent(john, bobby));

演示 - JSFiddle

如你所见，为了检查对象的“值是否相等”，我们本质上必须遍历对象中的每个属性，以查看它们是否相等。虽然这个简单的实现适用于我们的示例，但有很多情况它无法处理。例如:

如果其中一个属性值本身就是一个对象呢? 如果属性值之一是NaN(中唯一的值 JavaScript不等于它自己?) 如果a有一个值为undefined的属性，而b没有呢 这个属性(因此计算为undefined?)

对于一个健壮的检查对象“值是否相等”的方法，最好依赖于一个经过良好测试的库，它涵盖了各种边缘情况，如下划线。

var john = {
    occupation: "Web Developer",
    age: 25
};

var bobby = {
    occupation: "Web Developer",
    age: 25
};

// Outputs: true
console.log(_.isEqual(john, bobby));

演示 - JSFiddle