在Node.js中，你可以使用它的原生require("assert"). deepstrictequal。更多信息: http://nodejs.org/api/assert.html

例如:

var assert = require("assert");
assert.deepStrictEqual({a:1, b:2}, {a:1, b:3}); // will throw AssertionError

另一个返回true / false而不是返回错误的例子:

var assert = require("assert");

function deepEqual(a, b) {
    try {
      assert.deepEqual(a, b);
    } catch (error) {
      if (error.name === "AssertionError") {
        return false;
      }
      throw error;
    }
    return true;
};

从我的个人库中取出，我经常用它来工作。下面的函数是一个宽大的递归深度等号，它不检查

阶级平等 继承的值 价值观严格平等

我主要用这个来检查我是否得到了对各种API实现的相等的回复。可能会出现实现差异(如字符串与数字)和额外的空值。

它的实现非常简单(如果去掉所有注释的话)

/** Recursively check if both objects are equal in value *** *** This function is designed to use multiple methods from most probable *** (and in most cases) valid, to the more regid and complex method. *** *** One of the main principles behind the various check is that while *** some of the simpler checks such as == or JSON may cause false negatives, *** they do not cause false positives. As such they can be safely run first. *** *** # !Important Note: *** as this function is designed for simplified deep equal checks it is not designed *** for the following *** *** - Class equality, (ClassA().a = 1) maybe valid to (ClassB().b = 1) *** - Inherited values, this actually ignores them *** - Values being strictly equal, "1" is equal to 1 (see the basic equality check on this) *** - Performance across all cases. This is designed for high performance on the *** most probable cases of == / JSON equality. Consider bench testing, if you have *** more 'complex' requirments *** *** @param objA : First object to compare *** @param objB : 2nd object to compare *** @param .... : Any other objects to compare *** *** @returns true if all equals, or false if invalid *** *** @license Copyright by eugene@picoded.com, 2012. *** Licensed under the MIT license: http://opensource.org/licenses/MIT **/ function simpleRecusiveDeepEqual(objA, objB) { // Multiple comparision check //-------------------------------------------- var args = Array.prototype.slice.call(arguments); if(args.length > 2) { for(var a=1; a<args.length; ++a) { if(!simpleRecusiveDeepEqual(args[a-1], args[a])) { return false; } } return true; } else if(args.length < 2) { throw "simpleRecusiveDeepEqual, requires atleast 2 arguments"; } // basic equality check, //-------------------------------------------- // if this succed the 2 basic values is equal, // such as numbers and string. // // or its actually the same object pointer. Bam // // Note that if string and number strictly equal is required // change the equality from ==, to === // if(objA == objB) { return true; } // If a value is a bsic type, and failed above. This fails var basicTypes = ["boolean", "number", "string"]; if( basicTypes.indexOf(typeof objA) >= 0 || basicTypes.indexOf(typeof objB) >= 0 ) { return false; } // JSON equality check, //-------------------------------------------- // this can fail, if the JSON stringify the objects in the wrong order // for example the following may fail, due to different string order: // // JSON.stringify( {a:1, b:2} ) == JSON.stringify( {b:2, a:1} ) // if(JSON.stringify(objA) == JSON.stringify(objB)) { return true; } // Array equality check //-------------------------------------------- // This is performed prior to iteration check, // Without this check the following would have been considered valid // // simpleRecusiveDeepEqual( { 0:1963 }, [1963] ); // // Note that u may remove this segment if this is what is intended // if( Array.isArray(objA) ) { //objA is array, objB is not an array if( !Array.isArray(objB) ) { return false; } } else if( Array.isArray(objB) ) { //objA is not array, objB is an array return false; } // Nested values iteration //-------------------------------------------- // Scan and iterate all the nested values, and check for non equal values recusively // // Note that this does not check against null equality, remove the various "!= null" // if this is required var i; //reuse var to iterate // Check objA values against objB for (i in objA) { //Protect against inherited properties if(objA.hasOwnProperty(i)) { if(objB.hasOwnProperty(i)) { // Check if deep equal is valid if(!simpleRecusiveDeepEqual( objA[i], objB[i] )) { return false; } } else if(objA[i] != null) { //ignore null values in objA, that objB does not have //else fails return false; } } } // Check if objB has additional values, that objA do not, fail if so for (i in objB) { if(objB.hasOwnProperty(i)) { if(objB[i] != null && !objA.hasOwnProperty(i)) { //ignore null values in objB, that objA does not have //else fails return false; } } } // End of all checks //-------------------------------------------- // By reaching here, all iteration scans have been done. // and should have returned false if it failed return true; } // Sanity checking of simpleRecusiveDeepEqual (function() { if( // Basic checks !simpleRecusiveDeepEqual({}, {}) || !simpleRecusiveDeepEqual([], []) || !simpleRecusiveDeepEqual(['a'], ['a']) || // Not strict checks !simpleRecusiveDeepEqual("1", 1) || // Multiple objects check !simpleRecusiveDeepEqual( { a:[1,2] }, { a:[1,2] }, { a:[1,2] } ) || // Ensure distinction between array and object (the following should fail) simpleRecusiveDeepEqual( [1963], { 0:1963 } ) || // Null strict checks simpleRecusiveDeepEqual( 0, null ) || simpleRecusiveDeepEqual( "", null ) || // Last "false" exists to make the various check above easy to comment in/out false ) { alert("FATAL ERROR: simpleRecusiveDeepEqual failed basic checks"); } else { //added this last line, for SO snippet alert on success alert("simpleRecusiveDeepEqual: Passed all checks, Yays!"); } })();

需要一个比已经发布的更通用的对象比较函数，我炮制了以下。批判赞赏……

Object.prototype.equals = function(iObj) {
  if (this.constructor !== iObj.constructor)
    return false;
  var aMemberCount = 0;
  for (var a in this) {
    if (!this.hasOwnProperty(a))
      continue;
    if (typeof this[a] === 'object' && typeof iObj[a] === 'object' ? !this[a].equals(iObj[a]) : this[a] !== iObj[a])
      return false;
    ++aMemberCount;
  }
  for (var a in iObj)
    if (iObj.hasOwnProperty(a))
      --aMemberCount;
  return aMemberCount ? false : true;
}

简短的回答

简单的答案是:不，没有一般的方法来确定一个对象等于另一个你所指的意义。例外情况是当您严格地认为一个对象是无类型的。

长话短说

这个概念是一个Equals方法，它比较一个对象的两个不同实例，以指示它们在值级别上是否相等。但是，定义Equals方法应该如何实现取决于具体的类型。对具有基本值的属性进行迭代比较可能还不够:对象可能包含与相等无关的属性。例如,

 function MyClass(a, b)
 {
     var c;
     this.getCLazy = function() {
         if (c === undefined) c = a * b // imagine * is really expensive
         return c;
     }
  }

在上面的例子中，c对于确定MyClass的任何两个实例是否相等并不重要，只有a和b是重要的。在某些情况下，c可能在不同实例之间有所不同，但在比较中并不显著。

注意，当成员本身也可能是某个类型的实例，并且每个实例都需要有确定相等的方法时，这个问题就会出现。

更复杂的是，在JavaScript中，数据和方法之间的区别是模糊的。

一个对象可以引用一个作为事件处理程序调用的方法，这可能不被认为是其“值状态”的一部分。然而，另一个对象很可能被分配一个执行重要计算的函数，从而使这个实例与其他实例不同，仅仅因为它引用了不同的函数。

如果一个对象的现有原型方法被另一个函数覆盖，该怎么办?它还能被认为与另一个相同的实例相等吗?这个问题只能在每种类型的具体情况下回答。

如前所述，异常将是一个严格的无类型对象。在这种情况下，唯一明智的选择是对每个成员进行迭代和递归比较。即使这样，人们也要问一个函数的“值”是什么?

我看到了意大利式的代码答案。 不使用任何第三方的lib，这是非常容易的。

首先，按键对两个对象进行排序。

let objectOne = { hey, you }
let objectTwo = { you, hey }

// If you really wanted you could make this recursive for deep sort.
const sortObjectByKeyname = (objectToSort) => {
    return Object.keys(objectToSort).sort().reduce((r, k) => (r[k] = objectToSort[k], r), {});
}

let objectOne = sortObjectByKeyname(objectOne)
let objectTwo = sortObjectByKeyname(objectTwo)

然后简单地使用字符串来比较它们。

JSON.stringify(objectOne) === JSON.stringify(objectTwo)

这个问题已经有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。如果两者都不可能，选择第二条，最后是第一条。