如何确定两个 JavaScript 对象相等？

Question

严格相等运算符会告诉您两个对象类型是否相等。但是，有没有一种方法可以判断两个对象是否相等，很像 Java 中的哈希码值？

Stack Overflow 问题JavaScript 中是否有任何类型的 hashCode 函数？ 与此问题类似，但需要更学术的答案。上面的场景演示了为什么有必要拥有一个，我想知道是否有任何等效的解决方案。

Answer 1

为什么要重新发明轮子？尝试一下Lodash。它有许多必备函数，例如 isEqual()。

_.isEqual(object, other);

它将强力检查每个键值 - 就像本页上的其他示例一样 - 使用 ECMAScript 5< /a> 和本机优化（如果它们在浏览器中可用）。

注意：以前这个答案推荐 Underscore.js，但是 lodash 在修复错误和一致解决问题方面做得更好。

Answer 2

简短答案

简单的答案是：不，没有通用的方法可以确定一个对象与另一个对象在您的意思上相等。例外情况是当您严格认为对象是无类型的时。

长答案

这个概念是 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 中数据和方法之间的区别是模糊的。

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

如果一个对象的现有原型方法之一被另一个函数覆盖了怎么办？它仍然可以被认为等于另一个在其他方面相同的实例吗？这个问题只能根据每种类型的具体情况来回答。

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

Answer 3

当对象引用内存中的同一位置时，JavaScript 中对象的默认相等运算符将产生 true。

var x = {};
var y = {};
var z = x;

x === y; // => false
x === z; // => true

如果您需要不同的相等运算符，则需要向您的类添加一个 equals(other) 方法或类似的方法，并且问题域的具体情况将决定其确切含义。

这是一个扑克牌示例：

function Card(rank, suit) {
  this.rank = rank;
  this.suit = suit;
  this.equals = function(other) {
     return other.rank == this.rank && other.suit == this.suit;
  };
}

var queenOfClubs = new Card(12, "C");
var kingOfSpades = new Card(13, "S");

queenOfClubs.equals(kingOfSpades); // => false
kingOfSpades.equals(new Card(13, "S")); // => true

Answer 4

简短的函数 deepEqual 实现：

function deepEqual(x, y) {
  return (x && y && typeof x === 'object' && typeof y === 'object') ?
    (Object.keys(x).length === Object.keys(y).length) &&
      Object.keys(x).reduce(function(isEqual, key) {
        return isEqual && deepEqual(x[key], y[key]);
      }, true) : (x === y);
}

编辑：版本 2，使用 jib 的建议和 ES6 箭头函数：

function deepEqual(x, y) {
  const ok = Object.keys, tx = typeof x, ty = typeof y;
  return x && y && tx === 'object' && tx === ty ? (
    ok(x).length === ok(y).length &&
      ok(x).every(key => deepEqual(x[key], y[key]))
  ) : (x === y);
}

Answer 5

这是我的版本。它使用新的 Object.keys 功能ES5 中引入了来自 + 的想法/测试，+ 和 +：

function objectEquals(x, y) {
    'use strict';

    if (x === null || x === undefined || y === null || y === undefined) { return x === y; }
    // after this just checking type of one would be enough
    if (x.constructor !== y.constructor) { return false; }
    // if they are functions, they should exactly refer to same one (because of closures)
    if (x instanceof Function) { return x === y; }
    // if they are regexps, they should exactly refer to same one (it is hard to better equality check on current ES)
    if (x instanceof RegExp) { return x === y; }
    if (x === y || x.valueOf() === y.valueOf()) { return true; }
    if (Array.isArray(x) && x.length !== y.length) { return false; }

    // if they are dates, they must had equal valueOf
    if (x instanceof Date) { return false; }

    // if they are strictly equal, they both need to be object at least
    if (!(x instanceof Object)) { return false; }
    if (!(y instanceof Object)) { return false; }

    // recursive object equality check
    var p = Object.keys(x);
    return Object.keys(y).every(function (i) { return p.indexOf(i) !== -1; }) &&
        p.every(function (i) { return objectEquals(x[i], y[i]); });
}


///////////////////////////////////////////////////////////////
/// The borrowed tests, run them by clicking "Run code snippet"
///////////////////////////////////////////////////////////////
var printResult = function (x) {
    if (x) { document.write('<div style="color: green;">Passed</div>'); }
    else { document.write('<div style="color: red;">Failed</div>'); }
};
var assert = { isTrue: function (x) { printResult(x); }, isFalse: function (x) { printResult(!x); } }
assert.isTrue(objectEquals(null,null));
assert.isFalse(objectEquals(null,undefined));
assert.isFalse(objectEquals(/abc/, /abc/));
assert.isFalse(objectEquals(/abc/, /123/));
var r = /abc/;
assert.isTrue(objectEquals(r, r));

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}}));

Object.prototype.equals = function (obj) { return objectEquals(this, obj); };
var assertFalse = assert.isFalse,
    assertTrue = assert.isTrue;

assertFalse({}.equals(null));
assertFalse({}.equals(undefined));

assertTrue("hi".equals("hi"));
assertTrue(new Number(5).equals(5));
assertFalse(new Number(5).equals(10));
assertFalse(new Number(1).equals("1"));

assertTrue([].equals([]));
assertTrue([1,2].equals([1,2]));
assertFalse([1,2].equals([2,1]));
assertFalse([1,2].equals([1,2,3]));
assertTrue(new Date("2011-03-31").equals(new Date("2011-03-31")));
assertFalse(new Date("2011-03-31").equals(new Date("1970-01-01")));

assertTrue({}.equals({}));
assertTrue({a:1,b:2}.equals({a:1,b:2}));
assertTrue({a:1,b:2}.equals({b:2,a:1}));
assertFalse({a:1,b:2}.equals({a:1,b:3}));

assertTrue({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}.equals({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}));
assertFalse({1:{name:"mhc",age:28}, 2:{name:"arb",age:26}}.equals({1:{name:"mhc",age:28}, 2:{name:"arb",age:27}}));

var a = {a: 'text', b:[0,1]};
var b = {a: 'text', b:[0,1]};
var c = {a: 'text', b: 0};
var d = {a: 'text', b: false};
var e = {a: 'text', b:[1,0]};
var i = {
    a: 'text',
    c: {
        b: [1, 0]
    }
};
var j = {
    a: 'text',
    c: {
        b: [1, 0]
    }
};
var k = {a: 'text', b: null};
var l = {a: 'text', b: undefined};

assertTrue(a.equals(b));
assertFalse(a.equals(c));
assertFalse(c.equals(d));
assertFalse(a.equals(e));
assertTrue(i.equals(j));
assertFalse(d.equals(k));
assertFalse(k.equals(l));

// from comments on stackoverflow post
assert.isFalse(objectEquals([1, 2, undefined], [1, 2]));
assert.isFalse(objectEquals([1, 2, 3], { 0: 1, 1: 2, 2: 3 }));
assert.isFalse(objectEquals(new Date(1234), 1234));

// no two different function is equal really, they capture their context variables
// so even if they have same toString(), they won't have same functionality
var func = function (x) { return true; };
var func2 = function (x) { return true; };
assert.isTrue(objectEquals(func, func));
assert.isFalse(objectEquals(func, func2));
assert.isTrue(objectEquals({ a: { b: func } }, { a: { b: func } }));
assert.isFalse(objectEquals({ a: { b: func } }, { a: { b: func2 } }));

Answer 6

如果您使用 AngularJS，angular.equals 函数将确定两个对象是否相等平等的。在 Ember.js 中使用 isEqual。

• angular.equals - 请参阅 文档 或 来源了解有关此方法的更多信息。它也对数组进行深度比较。
• Ember.js isEqual - 请参阅 文档 或 来源了解更多信息方法。它不对数组进行深度比较。

var purple = [{"purple": "drank"}];
var drank = [{"purple": "drank"}];

if(angular.equals(purple, drank)) {
    document.write('got dat');
}

<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.4.5/angular.min.js"></script>

Answer 7

如果您使用的是 JSON 库，则可以将每个对象编码为 JSON，然后比较结果字符串是否相等。

var obj1={test:"value"};
var obj2={test:"value2"};

alert(JSON.encode(obj1)===JSON.encode(obj2));

注意：虽然这个答案在很多情况下都有效，但正如一些人在评论中指出的那样，它由于多种原因而存在问题。几乎在所有情况下，您都希望找到更强大的解决方案。

Answer 8

对于那些使用 Node 的人来说，原生 util 库上有一个名为 isDeepStrictEqual 的便捷方法可以实现此目的。

const util = require('util');

const obj1 = {
  foo: "bar",
  baz: [1, 2]
};

const obj2 = {
  foo: "bar",
  baz: [1, 2]
};


obj1 == obj2 // false
util.isDeepStrictEqual(obj1, obj2) // true

https://nodejs.org/api/util.html#util_util_isdeepstrictequal_val1_val2

Answer 9

在 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

另一个返回 < 的示例code>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;
};

Answer 10

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

你有4+1类解决方案：

---

1）使用一种不完整的快速单行

如果你很匆忙并且99%的正确率有效。

这方面的例子是， JSON.stringify() 建议 Pratik Bhalodiya，或JSON.encode 作者：Joel Anair，或 .toString()或其他将对象转换为字符串，然后使用 === 逐个字符比较两个字符串的方法。

然而，缺点是字符串中的对象没有全球标准的唯一表示形式。例如 { a: 5, b: 8} 和 {b: 8 and a: 5 } 是相等的。

• 优点：快，快。
• 缺点：希望有效！ 如果环境/浏览器/引擎记住对象的顺序（例如Chrome/V8）并且键的顺序不同，则它将无法工作（感谢Eksapsy。）所以，根本不能保证。对于大型对象，性能也不会很好。

我的父亲类比

当我谈论我的父亲时，“我高大帅气的父亲”和“我英俊高大的父亲”是同一个人！但这两个字符串并不相同。

请注意，英语语法中实际上存在正确（标准方式）的形容词顺序，即说它应该是一个“英俊的高个子男人”，但是如果你盲目地假设 iOS 8 Safari 的 Javascript 引擎也遵守相同的语法，那么你就是在拿自己的能力冒险！ #WelcomeToJavascriptNonStandards

---

2) 编写自己的 DIY 递归函数

如果您正在学习，那就太好了。

示例是 atmin 的解决方案。

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

我只会鼓励人们在练习并且代码不会投入生产时这样做。这是重新发明轮子有理由的唯一情况。

• 优点：学习机会。
• 缺点：不可靠。需要时间和关注。

我的父亲类比

这就像假设如果我父亲的名字是“约翰·史密斯”并且他的生日是“1/1/1970”，那么任何名字是“约翰·史密斯”并且出生于“1/1/1970”的人都是我的父亲。

通常情况都是如此，但是如果那天有两个“约翰·史密斯”出生怎么办？如果您认为您会考虑他们的身高，那么这会提高准确性，但仍然不是完美的比较。

2.1 有限范围的 DIY 比较器

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

它仍然不是一个完美的解决方案，但相对于解决方案 2 的优点是：

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

---

3) 使用equal函数的库版本

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

示例为_。 equal lodash，已在 coolaj86的答案或Tony Harvey 的回答 或 Node 的作者：拉斐尔·泽维尔。

• 优点：这是其他人所做的。
• 缺点：外部依赖，这可能会花费您额外的内存/CPU/安全问题，即使是一点点。此外，仍然可能会错过一些边缘情况（例如，两个具有相同ownProperties但原型父代不同的对象是否应被视为相同。）最后，您可能无意中解决了潜在的设计问题；只是说！

我的父亲类比

这就像花钱找一家机构根据他的电话、姓名、地址等找到我的亲生父亲。

这会花费更多，而且可能比我自己进行背景调查更准确，但是不包括边缘情况，例如我的父亲是移民/庇护且他的生日未知！

---

4) 在对象中使用标识符

如果您[仍然]可以更改系统的设计（您正在处理的对象）并且希望您的代码持续很长时间，那么很好。

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

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

ID 可以是简单的 auto_incremental 数字，也可以是通过库（建议）或一段代码。您需要做的就是确保它始终是唯一的，在 auto_incremental 的情况下，它可以是内置的，或者在 UUID 的情况下，可以检查所有现有值（例如 MySQL 的 UNIQUE 列属性）或简单地（如果来自库）依赖于提供极低的冲突可能性。

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

• 优点：可靠、高效、不脏、现代。
• 缺点：需要额外的空间。可能需要重新设计系统。

我父亲的类比

就像知道我父亲的社会安全号码是 911-345-9283，所以任何拥有这个 SSN 的人都是我的父亲，任何自称是我父亲的人都必须拥有这个 SSN。

---

结论

就准确性和可靠性而言，我个人更喜欢解决方案 #4 (ID)。如果不可能的话，为了可预测性，我会选择#2.1，然后选择#3。如果两者都不可能，则#2，最后#1。

Answer 11

您是否想测试两个对象是否相等？即：它们的属性相等吗？

如果是这种情况，您可能会注意到这种情况：

var a = { foo : "bar" };
var b = { foo : "bar" };
alert (a == b ? "Equal" : "Not equal");
// "Not equal"

您可能必须这样做：

function objectEquals(obj1, obj2) {
    for (var i in obj1) {
        if (obj1.hasOwnProperty(i)) {
            if (!obj2.hasOwnProperty(i)) return false;
            if (obj1[i] != obj2[i]) return false;
        }
    }
    for (var i in obj2) {
        if (obj2.hasOwnProperty(i)) {
            if (!obj1.hasOwnProperty(i)) return false;
            if (obj1[i] != obj2[i]) return false;
        }
    }
    return true;
}

显然该函数可以进行大量优化，并且能够进行深度检查（以处理嵌套对象：< code>var a = { foo : { fu : "bar" } }) 但你明白了。

正如 FOR 指出的，您可能必须根据自己的目的进行调整，例如：不同的类可能有不同的“等于”定义。如果您只使用普通对象，上述内容可能就足够了，否则自定义 MyClass.equals() 函数可能是正确的选择。

Answer 12

var object1 = {name: "humza" , gender : "male", age: 23}
var object2 = {name: "humza" , gender : "male", age: 23}
var result = Object.keys(object1).every((key) =>  object1[key] === object2[key])

如果对象 1 与对象 2 具有相同的值，结果将为 true。

Answer 13

如果您有方便的深度复制功能，则可以使用以下技巧在匹配属性顺序时仍然使用JSON.stringify：

function equals(obj1, obj2) {
    function _equals(obj1, obj2) {
        return JSON.stringify(obj1)
            === JSON.stringify($.extend(true, {}, obj1, obj2));
    }
    return _equals(obj1, obj2) && _equals(obj2, obj1);
}

演示：http://jsfiddle.net/CU3vb/3/

理由：

由于 obj1 的属性被复制克隆人一一按照顺序克隆中的内容将被保留。当 obj2 的属性复制到克隆时，由于 obj1 中已经存在的属性将被简单地覆盖，因此它们在克隆中的顺序将被保留。

Answer 14

用于比较所有内容的最简单和逻辑解决方案，例如对象、数组、字符串、整数...

JSON.stringify({a: val1 }) === JSON.stringify({a: val2})

注意：

• 您需要将 val1 和 val2 替换为您的
• 对象，您必须对双方递归排序（按键）物体

Answer 15

我使用这个 comparable 函数来生成可与 JSON 进行比较的对象的副本：

var comparable = o => (typeof o != 'object' || !o)? o :
  Object.keys(o).sort().reduce((c, key) => (c[key] = comparable(o[key]), c), {});

// Demo:

var a = { a: 1, c: 4, b: [2, 3], d: { e: '5', f: null } };
var b = { b: [2, 3], c: 4, d: { f: null, e: '5' }, a: 1 };

console.log(JSON.stringify(comparable(a)));
console.log(JSON.stringify(comparable(b)));
console.log(JSON.stringify(comparable(a)) == JSON.stringify(comparable(b)));

<div id="div"></div>

在测试中派上用场（大多数测试框架都有 is 函数）。例如

is(JSON.stringify(comparable(x)), JSON.stringify(comparable(y)), 'x must match y');

，如果发现差异，则会记录字符串，从而使差异易于发现：

x must match y
got      {"a":1,"b":{"0":2,"1":3},"c":7,"d":{"e":"5","f":null}},
expected {"a":1,"b":{"0":2,"1":3},"c":4,"d":{"e":"5","f":null}}.

Answer 16

这是 ES6/ES2015 中使用函数式方法的解决方案：

const typeOf = x => 
  ({}).toString
      .call(x)
      .match(/\[object (\w+)\]/)[1]

function areSimilar(a, b) {
  const everyKey = f => Object.keys(a).every(f)

  switch(typeOf(a)) {
    case 'Array':
      return a.length === b.length &&
        everyKey(k => areSimilar(a.sort()[k], b.sort()[k]));
    case 'Object':
      return Object.keys(a).length === Object.keys(b).length &&
        everyKey(k => areSimilar(a[k], b[k]));
    default:
      return a === b;
  }
}

此处提供演示

Answer 17

我不知道是否有人发布了与此类似的内容，但这是我用来检查对象相等性的函数。

function objectsAreEqual(a, b) {
  for (var prop in a) {
    if (a.hasOwnProperty(prop)) {
      if (b.hasOwnProperty(prop)) {
        if (typeof a[prop] === 'object') {
          if (!objectsAreEqual(a[prop], b[prop])) return false;
        } else {
          if (a[prop] !== b[prop]) return false;
        }
      } else {
        return false;
      }
    }
  }
  return true;
}

此外，它是递归的，因此它还可以检查深度相等（如果您这么称呼它）。

Answer 18

ES6：我能完成的最少代码是这样的。它通过对表示对象的所有排序的键值数组进行字符串化来递归地进行深度比较，唯一的限制是没有方法或符号进行比较。

const compareObjects = (a, b) => { 
  let s = (o) => Object.entries(o).sort().map(i => { 
     if(i[1] instanceof Object) i[1] = s(i[1]);
     return i 
  }) 
  return JSON.stringify(s(a)) === JSON.stringify(s(b))
}

console.log(compareObjects({b:4,a:{b:1}}, {a:{b:1},b:4}));

重要：此函数在 ARRAY 中执行 JSON.stringfy，其中键已排序，NOT 在其自身的对象中：

1. ["a" , [“b”, 1]]
2. [“b”, 4]

Answer 19

下面是一个简短的实现，它使用 JSON.stringify 但按照@Jor 此处的建议对键进行排序。

一些测试取自@EbrahimByagowi 此处的答案。

当然，通过使用 JSON.stringify，解决方案仅限于 JSON 可序列化类型（字符串、数字、JSON 对象、数组、布尔值、null）。不支持 Date、Function 等对象。

function objectEquals(obj1, obj2) {
  const JSONstringifyOrder = obj => {
    const keys = {};
    JSON.stringify(obj, (key, value) => {
      keys[key] = null;
      return value;
    });
    return JSON.stringify(obj, Object.keys(keys).sort());
  };
  return JSONstringifyOrder(obj1) === JSONstringifyOrder(obj2);
}

///////////////////////////////////////////////////////////////
/// The borrowed tests, run them by clicking "Run code snippet"
///////////////////////////////////////////////////////////////
var printResult = function (x) {
    if (x) { document.write('<div style="color: green;">Passed</div>'); }
    else { document.write('<div style="color: red;">Failed</div>'); }
};
var assert = { isTrue: function (x) { printResult(x); }, isFalse: function (x) { printResult(!x); } }

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}}));

Answer 20

只是想利用一些 es6 功能贡献我的对象比较版本。它不考虑订单。将所有 if/else 转换为三元后，我得到以下结果：

function areEqual(obj1, obj2) {

    return Object.keys(obj1).every(key => {

            return obj2.hasOwnProperty(key) ?
                typeof obj1[key] === 'object' ?
                    areEqual(obj1[key], obj2[key]) :
                obj1[key] === obj2[key] :
                false;

        }
    )
}

Answer 21

您可以使用 underscore.js 库中的 _.isEqual(obj1, obj2) 。

这是一个示例：

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

Answer 22

我发现比较两个 javascript 对象值同时忽略属性顺序的一种简单方法是使用 JSON stringify 替换函数：

const compareReplacer = (key, value) => {
    if(typeof value === 'object' && !(value instanceof Array))
        return Object.entries(value).sort();
    return value;
}
export const compareObjects = (a, b) => JSON.stringify(a, compareReplacer) === JSON.stringify(b, compareReplacer);

这将在每一步对属性进行排序，以便字符串结果与属性顺序保持不变。有人可能以前做过这个，但我只是想我会分享它，以防万一没有:)。

Answer 23

编辑：这种方法有很大缺陷，并且充满了自己的问题。我不推荐它，并且希望有一些反对票！这是有问题的，因为 1) 有些东西无法比较（即函数），因为它们无法序列化，2) 这不是一种非常快的比较方法，3) 它有排序问题，4) 它可能有冲突问题/如果未正确实现，则会出现误报，5) 它无法检查“准确性”(===)，而是基于值相等，这通常不是比较中所需的方法。

许多人没有意识到这个问题的一个简单解决方案是对 JSON 字符串（每个字符）进行排序。这通常也比此处提到的其他解决方案更快：

function areEqual(obj1, obj2) {
    var a = JSON.stringify(obj1), b = JSON.stringify(obj2);
    if (!a) a = '';
    if (!b) b = '';
    return (a.split('').sort().join('') == b.split('').sort().join(''));
}

此方法的另一个有用的事情是您可以通过将“replacer”函数传递给 JSON.stringify 函数来过滤比较（https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#Example_of_using_replacer_parameter）。以下仅比较名为“derp”的所有对象键：

function areEqual(obj1, obj2, filter) {
    var a = JSON.stringify(obj1, filter), b = JSON.stringify(obj2, filter);
    if (!a) a = '';
    if (!b) b = '';
    return (a.split('').sort().join('') == b.split('').sort().join(''));
}
var equal = areEqual(obj1, obj2, function(key, value) {
    return (key === 'derp') ? value : undefined;
});

Answer 24

简而言之：

const compare = (x, y) => {
  const srt = (obj) => JSON.stringify(obj)?.split('').sort().join('');
  return srt(x) === srt(y);
};

// ----- How to use ---
const a = {'one':1, 'two':2,'three':3};
const b = {'two':2, 'one':1, 'three':3}; //note same values as (const a)
const c = {'one':1, 'two':2,'three':3};
const d = {'one':1, 'two':2,'four':4};

compare(a, b); //true
compare(a, c); //true
compare(a, d); //false

//----- BUT! -----
JSON.stringify(a) === JSON.stringify(b); //false

//----- AND -----
compare({}, {}); //true
compare({}, undefined); //false
compare(undefined, undefined); //true
compare(undefined, ''); //false
compare(undefined, null); //false
compare(null, null); //true
compare('', ''); //true

Answer 25

由于需要一个比已发布的更通用的对象比较函数，我编写了以下内容。批评表示赞赏...

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;
}

Answer 26

如果您要比较 JSON 对象，可以使用 https://github.com/mirek/node-rus- diff

npm install rus-diff

用法：

a = {foo:{bar:1}}
b = {foo:{bar:1}}
c = {foo:{bar:2}}

var rusDiff = require('rus-diff').rusDiff

console.log(rusDiff(a, b)) // -> false, meaning a and b are equal
console.log(rusDiff(a, c)) // -> { '$set': { 'foo.bar': 2 } }

如果两个对象不同，则为 MongoDB 兼容 {$rename:{...}, $unset:{...}, $set:{...}} 返回类似对象。

Answer 27

我遇到了同样的问题并决定编写自己的解决方案。但因为我还想将数组与对象进行比较，反之亦然，所以我设计了一个通用的解决方案。我决定将这些函数添加到原型中，但可以轻松地将它们重写为独立函数。这是代码：

Array.prototype.equals = Object.prototype.equals = function(b) {
    var ar = JSON.parse(JSON.stringify(b));
    var err = false;
    for(var key in this) {
        if(this.hasOwnProperty(key)) {
            var found = ar.find(this[key]);
            if(found > -1) {
                if(Object.prototype.toString.call(ar) === "[object Object]") {
                    delete ar[Object.keys(ar)[found]];
                }
                else {
                    ar.splice(found, 1);
                }
            }
            else {
                err = true;
                break;
            }
        }
    };
    if(Object.keys(ar).length > 0 || err) {
        return false;
    }
    return true;
}

Array.prototype.find = Object.prototype.find = function(v) {
    var f = -1;
    for(var i in this) {
        if(this.hasOwnProperty(i)) {
            if(Object.prototype.toString.call(this[i]) === "[object Array]" || Object.prototype.toString.call(this[i]) === "[object Object]") {
                if(this[i].equals(v)) {
                    f = (typeof(i) == "number") ? i : Object.keys(this).indexOf(i);
                }
            }
            else if(this[i] === v) {
                f = (typeof(i) == "number") ? i : Object.keys(this).indexOf(i);
            }
        }
    }
    return f;
}

该算法分为两部分； equals 函数本身和一个用于查找数组/对象中属性的数字索引的函数。之所以需要 find 函数，是因为 indexof 只查找数字和字符串，而不查找对象。

可以这样调用它：

({a: 1, b: "h"}).equals({a: 1, b: "h"});

该函数返回 true 或 false，在本例中为 true。
该算法还允许在非常复杂的对象之间进行比较：

({a: 1, b: "hello", c: ["w", "o", "r", "l", "d", {answer1: "should be", answer2: true}]}).equals({b: "hello", a: 1, c: ["w", "d", "o", "r", {answer1: "should be", answer2: true}, "l"]})

上面的示例将返回 true，即使属性具有不同的顺序。需要注意的一个小细节：此代码还检查两个变量的类型是否相同，因此“3”与 3 不同。

Answer 28

假设对象中属性的顺序没有改变。

JSON .stringify() 适用于深度和非深度两种类型的对象，不太确定性能方面：

var object1 = {
  key: "value"
};

var object2 = {
  key: "value"
};

var object3 = {
  key: "no value"
};

console.log('object1 and object2 are equal: ', JSON.stringify(object1) === JSON.stringify(object2));

console.log('object2 and object3 are equal: ', JSON.stringify(object2) === JSON.stringify(object3));

Answer 29

如何确定部分对象（Partial）等于打字稿中的原始对象（T）。

function compareTwoObjects<T>(original: T, partial: Partial<T>): boolean {
  return !Object.keys(partial).some((key) => partial[key] !== original[key]);
}

PS 最初我打算创建一个带有答案的新问题。但这样的问题已经存在并标记为重复。

Answer 30

简而言之，这将检查两个变量的相等性，无论类型如何。

function isSame (obj1, obj2) {
  const obj1Keys = Object.keys(obj1)
  const obj2Keys = Object.keys(obj2)

  return obj1Keys.length === obj2Keys.length && obj1Keys.every((key) => obj1[key] === obj2[key])
}