Wie bestimmt man die Gleichheit zweier JavaScript-Objekte?

Question

Ein strikter Gleichheitsoperator sagt Ihnen, ob zwei Objekte Typen gleich sind. Gibt es jedoch eine Möglichkeit zu erkennen, ob zwei Objekte gleich sind, ähnlich wie der Hash-Code Wert in Java?

Stack Overflow Frage Gibt es irgendeine Art von HashCode-Funktion in JavaScript? ist dieser Frage ähnlich, erfordert aber eine eher akademische Antwort. Das obige Szenario zeigt, warum es notwendig wäre, eine zu haben, und ich frage mich, ob es irgendeine gleichwertige Lösung .

Answer 1

Hier ist eine Lösung in ES6/ES2015 mit einem funktionalen Ansatz:

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

Demo hier verfügbar

Answer 2

Ich weiß nicht, ob schon jemand etwas Ähnliches gepostet hat, aber hier ist eine Funktion, die ich gemacht habe, um auf Objektgleichheiten zu prüfen.

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

Außerdem ist es rekursiv, so dass es auch auf tiefe Gleichheit prüfen kann, wenn Sie es so nennen.

Answer 3

ES6: Der minimale Code, den ich hinbekommen könnte, ist dieser. Es tun tiefe Vergleich rekursiv durch stringifying alle Schlüssel-Wert-Array sortiert, die das Objekt, die einzige Einschränkung ist keine Methoden oder Symbole zu vergleichen sind.

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

WICHTIG! Diese Funktion führt einen JSON.stringfy in einer ARRAY mit den sortierten Schlüsseln und PAS in dem Objekt selbst:

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

Answer 4

Nachfolgend finden Sie eine kurze Implementierung, bei der JSON.stringify aber sortiert die Schlüssel wie von @Jor vorgeschlagen aquí .

Einige Tests wurden aus der Antwort von @EbrahimByagowi übernommen aquí .

Natürlich, durch die Verwendung von JSON.stringify ist die Lösung auf JSON-serialisierbare Typen beschränkt (eine Zeichenkette, eine Zahl, ein JSON-Objekt, ein Array, ein Boolean, null). Objekte wie Date , Function usw. werden nicht unterstützt.

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 5

EDIT: Diese Methode ist ziemlich mangelhaft und birgt ihre eigenen Probleme. Ich empfehle sie nicht und würde mich über einige Ablehnungen freuen! Sie ist problematisch, weil 1) einige Dinge nicht verglichen werden können (z.B. Funktionen), weil sie nicht serialisiert werden können, 2) es ist keine sehr schnelle Vergleichsmethode, 3) es gibt Probleme mit der Reihenfolge, 4) es kann Kollisionsprobleme/falsch-positive Ergebnisse geben, wenn es nicht richtig implementiert ist, 5) es kann nicht auf "Exaktheit" geprüft werden ( === ) und basiert stattdessen auf der Gleichheit der Werte, was oft nicht das ist, was bei einer Vergleichsmethode erwünscht ist.

Eine einfache Lösung für dieses Problem, die viele Leute nicht kennen, ist die Sortierung der JSON-Strings (nach Zeichen). Dies ist in der Regel auch schneller als die anderen hier genannten Lösungen:

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

Ein weiterer nützlicher Aspekt dieser Methode ist, dass Sie Vergleiche filtern können, indem Sie eine "Replacer"-Funktion an die JSON.stringify-Funktionen übergeben ( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#Example_of_using_replacer_parameter ). Im Folgenden werden nur alle Objektschlüssel verglichen, die den Namen "derp" tragen:

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