Mehrere Möglichkeiten zum Vergleichen von Objekten in JavaScript

Der folgende Artikel zeigt Ihnen vier Möglichkeiten, JavaScript-Objekte richtig zu vergleichen. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.

Der Vergleich von Rohwerten in JavaScript ist sehr einfach. Verwenden Sie einfach einen der verfügbaren Gleichheitsoperatoren, beispielsweise den strikten Gleichheitsoperator:

'a' === 'c'; // => false
1   === 1;   // => true

Da Objekte jedoch strukturierte Daten haben, ist ein Vergleich schwierig. In diesem Artikel erfahren Sie, wie Sie Objekte in JavaScript richtig vergleichen.

1. Referenzvergleich

JavaScript bietet drei Methoden zum Vergleichen von Werten:

• Strenger Gleichheitsoperator ===
===
• 宽松相等运算符 ==
• Object.is() 函数

当使用上述任何一种方法比较对象时，只有在比较的值引用了相同的对象实例时，比较的评估结果为 true。这就是参照相等性。

让我们定义对象 hero1 和 hero2 ，并查看实际中的参照相等性：

const hero1 = {
  name: 'Batman'
};
const hero2 = {
  name: 'Batman'
};

hero1 === hero1; // => true
hero1 === hero2; // => false

hero1 == hero1; // => true
hero1 == hero2; // => false

Object.is(hero1, hero1); // => true
Object.is(hero1, hero2); // => false

hero1 === hero1 的计算结果为 true，因为两个操作数均指向了同一个对象实例 hero1。

另一方面，hero1 === hero2 的计算结果为 false，因为 hero1 和 hero2 是不同的对象实例。

有意思的是，hero1 和 hero2 对象的内容是相同的：两个对象都有一个 name 属性，它的其值是 'Batman'。尽管如此，即使比较相同结构的对象，hero1 === hero2  的结果也是 false。

当你想比较对象引用而不是它们的内容时，引用相等是很有用的。但是在更多的情况之下，你都想针对对象的实际内容进行比较：例如属性及它们的值。

接下来看看如何通过对象的内容比较对象是否相等。

2.手动比较

按内容比较对象最直接的方法是读取属性并手动比较它们。

例如，让我们编写一个特殊的函数 isHeroEqual() 来比较两个 hero 对象：

function isHeroEqual(object1, object2) {
  return object1.name === object2.name;
}

const hero1 = {
  name: 'Batman'
};
const hero2 = {
  name: 'Batman'
};
const hero3 = {
  name: 'Joker'
};

isHeroEqual(hero1, hero2); // => true
isHeroEqual(hero1, hero3); // => false

isHeroEqual() 访问两个对象的属性 name 并比较它们的值。

如果被比较的对象具有一些属性，我更喜欢编写诸如 isHeroEqual() 之类的比较函数。这类函数具有良好的性能：在比较中只会涉及少数几个属性访问器和相等运算符。

手动比较需要手动提取属性，对于简单对象来说，这不是问题。但是，要对较大的对象（或结构未知的对象）进行比较，就不方便了，因为它需要大量的样板代码。

那么让我们来看看对象的浅层比较能提供哪些帮助。

3. 浅层比较

如果用浅层比较检查对象，你必须获取两个对象的属性列表（使用 Object.keys()），然后检查它们的属性值是否相等。

下面的代码是浅层比较的一种实现方式：

function shallowEqual(object1, object2) {
  const keys1 = Object.keys(object1);
  const keys2 = Object.keys(object2);

  if (keys1.length !== keys2.length) {
    return false;
  }

  for (let index = 0; index < keys1.length; index++) {
    const val1 = object1[keys1[index]];
    const val2 = object2[keys2[index]];
    if (val1 !== val2) {
      return false;
    }
  }

  return true;
}

在函数内部，keys1 和 keys2 是分别包含 object1 和 object2 属性名称的数组。

用 for 循环遍历键，并比较 object1 和 object2 的每个属性。

使用浅层比较，你可以轻松对有着许多属性的对象进行相等性检查：

const hero1 = {
  name: 'Batman',
  realName: 'Bruce Wayne'
};
const hero2 = {
  name: 'Batman',
  realName: 'Bruce Wayne'
};
const hero3 = {
  name: 'Joker'
};

shallowEqual(hero1, hero2); // => true
shallowEqual(hero1, hero3); // => false

shallowEqual(hero1, hero2) 返回 true，因为对象 hero1 和 hero2 具有相同的属性（name 和 realName），并且值也相同。

另一方面，由于 hero1 和 hero3 具有不同的属性，所以 shallowEqual(hero1, hero3)  将会返回 false。

但是 JavaScript 中的对象是可以嵌套的。在这种情况下，浅层比较并不能很好地发挥作用。

下面对具有嵌套对象的对象执行浅层比较检查：

const hero1 = {
  name: 'Batman',
  address: {
    city: 'Gotham'
  }
};
const hero2 = {
  name: 'Batman',
  address: {
    city: 'Gotham'
  }
};

shallowEqual(hero1, hero2); // => false

这次，即使两个对象 hero1 和 hero2 具有相同的内容，shallowEqual(hero1, hero2)  也将会返回 false。

发生这种情况是因为嵌套对象 hero1.address 和 hero2.address 是不同的对象实例。因此，浅层比较认为  hero1.address 和 hero2.addressLoser Gleichheitsoperator ==

Object.is() Funktion

Beim Vergleichen von Objekten mit einer der oben genannten Methoden werden nur die verglichenen Werte angezeigt. Wenn auf dieselbe Objektinstanz verwiesen wird, Der Vergleich ergibt true. Das ist Referenzgleichheit.

Lassen Sie uns die Objekte hero1 und hero2 definieren und die Referenzgleichheit in Aktion sehen:

function deepEqual(object1, object2) {
  const keys1 = Object.keys(object1);
  const keys2 = Object.keys(object2);

  if (keys1.length !== keys2.length) {
    return false;
  }

  for (let index = 0; index < keys1.length; index++) {
    const val1 = object1[keys1[index]];
    const val2 = object2[keys2[index]];
    const areObjects = isObject(val1) && isObject(val2);
    if (areObjects && !deepEqual(val1, val2) || 
        !areObjects && val1 !== val2) {
      return false;
    }
  }

  return true;
}

function isObject(object) {
  return object != null && typeof object === &#39;object&#39;;
}

hero1 === hero1 Berechnung Das Ergebnis ist true, da beide Operanden auf dieselbe Objektinstanz hero1 verweisen.

Andererseits wird hero1 === hero2 als false ausgewertet, da hero1 und hero2 unterschiedliche Objekte sind Instanzen.

Interessanterweise sind die Inhalte der Objekte hero1 und hero2 gleich: Beide Objekte haben ein Attribut name, dessen Wert ist. Batman'. Dennoch ist das Ergebnis von hero1 === hero2 auch beim Vergleich von Objekten derselben Struktur false.

🎜Referenzgleichheit ist nützlich, wenn Sie Objektreferenzen und nicht deren Inhalte vergleichen möchten. In den meisten Fällen möchten Sie jedoch Objekte anhand ihres tatsächlichen Inhalts vergleichen: zum Beispiel Eigenschaften und ihre Werte. 🎜🎜 Als Nächstes sehen wir uns an, wie man Objekte anhand ihres Inhalts auf Gleichheit vergleicht. 🎜🎜🎜2. Manueller Vergleich 🎜🎜🎜Der einfachste Weg, Objekte nach Inhalt zu vergleichen, besteht darin, die Eigenschaften zu lesen und sie manuell zu vergleichen. 🎜🎜Lassen Sie uns zum Beispiel eine spezielle Funktion isHeroEqual() schreiben, um zwei Heldenobjekte zu vergleichen: 🎜

const hero1 = {
  name: 'Batman',
  address: {
    city: 'Gotham'
  }
};
const hero2 = {
  name: 'Batman',
  address: {
    city: 'Gotham'
  }
};

deepEqual(hero1, hero2); // => true

🎜isHeroEqual() Greifen Sie auf die Eigenschaften beider Objekte zu Name und vergleichen Sie ihre Werte. 🎜🎜Wenn die zu vergleichenden Objekte einige Eigenschaften haben, schreibe ich lieber Vergleichsfunktionen wie isHeroEqual(). Solche Funktionen weisen eine gute Leistung auf: Am Vergleich sind nur wenige Eigenschaftszugriffsfunktionen und Gleichheitsoperatoren beteiligt. 🎜🎜Manueller Vergleich erfordert das manuelle Extrahieren von Eigenschaften, was für einfache Objekte kein Problem darstellt. Der Vergleich größerer Objekte (oder Objekte, deren Struktur unbekannt ist) ist jedoch unpraktisch, da hierfür viel Boilerplate-Code erforderlich ist. 🎜🎜Mal sehen, wie ein oberflächlicher Vergleich von Objekten helfen kann. 🎜🎜🎜3. Flacher Vergleich🎜🎜🎜Wenn Sie Objekte mithilfe eines flachen Vergleichs prüfen, müssen Sie die Eigenschaftslisten beider Objekte abrufen (mithilfe von Object.keys()) und dann überprüfen, ob ihre Eigenschaftswerte gleich sind . 🎜🎜Der folgende Code ist eine Implementierungsmethode für einen flachen Vergleich: 🎜rrreee🎜Innerhalb der Funktion enthalten keys1 und keys2 jeweils object1 und ein Array von object2-Eigenschaftsnamen. 🎜🎜Verwenden Sie for, um die Schlüssel zu durchlaufen und jede Eigenschaft von object1 und object2 zu vergleichen. 🎜🎜Mit dem flachen Vergleich können Sie die Gleichheit von Objekten mit vielen Eigenschaften leicht überprüfen: 🎜rrreee🎜shallowEqual(hero1, hero2) gibt true zurück, weil das Objekthero1 und hero2 haben die gleichen Eigenschaften (name und realName) und haben die gleichen Werte. 🎜🎜Da andererseits hero1 und hero3 unterschiedliche Eigenschaften haben, gibt shallowEqual(hero1, hero3) false zurück. Code>. 🎜🎜Aber Objekte in JavaScript können verschachtelt sein. Flache Vergleiche funktionieren in diesem Fall nicht gut. 🎜🎜Im Folgenden wird eine oberflächliche Vergleichsprüfung für ein Objekt mit verschachtelten Objekten durchgeführt: 🎜rrreee🎜Dieses Mal, obwohl die beiden Objekte <code>hero1 und hero2 denselben Inhalt haben, shallowEqual(hero1, hero2) gibt auch false zurück. 🎜🎜Dies geschieht, weil die verschachtelten Objekte hero1.address und hero2.address unterschiedliche Objektinstanzen sind. Daher betrachtet ein flacher Vergleich hero1.address und hero2.address als zwei verschiedene Werte. 🎜🎜Das Lösen von Problemen mit verschachtelten Objekten erfordert einen umfassenden Vergleich. 🎜🎜🎜4. Tiefer Vergleich🎜🎜🎜Der tiefe Vergleich ähnelt dem flachen Vergleich, mit der Ausnahme, dass ein rekursiver flacher Vergleich für verschachtelte Objekte durchgeführt wird. 🎜🎜Sehen Sie sich die Implementierung des Tiefenvergleichs an: 🎜

function deepEqual(object1, object2) {
  const keys1 = Object.keys(object1);
  const keys2 = Object.keys(object2);

  if (keys1.length !== keys2.length) {
    return false;
  }

  for (let index = 0; index < keys1.length; index++) {
    const val1 = object1[keys1[index]];
    const val2 = object2[keys2[index]];
    const areObjects = isObject(val1) && isObject(val2);
    if (areObjects && !deepEqual(val1, val2) || 
        !areObjects && val1 !== val2) {
      return false;
    }
  }

  return true;
}

function isObject(object) {
  return object != null && typeof object === &#39;object&#39;;
}

第 13 行的 areObjects && !deepEqual(val1, val2)  一旦检查到的属性是对象，则递归调用将会开始验证嵌套对象是否也相等。

现在用 deepEquality() 比较具有嵌套对象的对象：

const hero1 = {
  name: 'Batman',
  address: {
    city: 'Gotham'
  }
};
const hero2 = {
  name: 'Batman',
  address: {
    city: 'Gotham'
  }
};

deepEqual(hero1, hero2); // => true

深度比较函数能够正确地确定 hero1 和 hero2 是否具有相同的属性和值，包括嵌套对象  hero1.address  和 hero2.address 的相等性。

为了深入比较对象，我建议使用Node内置util模块的  isDeepStrictEqual(object1, object2)  或lodash 库的 _.isEqual(object1, object2) 。

5. 总结

引用相等性（使用  ===、 == 或 Object.is()）用来确定操作数是否为同一个对象实例。

手动检查对象是否相等，需要对属性值进行手动比较。尽管这类检查需要手动编码来对属性进行比较，但由于很简单，所以这种方法很方便。

当被比较的对象有很多属性或在运行时确定对象的结构时，更好的方法是使用浅层检查。

如果比较的对象具有嵌套对象，则应该进行深度比较检查。

英文原文地址：https://dmitripavlutin.com/how-to-compare-objects-in-javascript/

作者：Dmitri Pavlutin

译文地址：https://segmentfault.com/a/1190000022913676

更多编程相关知识，请访问：编程入门！！

Das obige ist der detaillierte Inhalt vonMehrere Möglichkeiten zum Vergleichen von Objekten in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!