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 gibt es viele gute Gedanken! Hier ist meine Version von deep equal. Ich habe sie auf github gepostet und einige Tests dazu geschrieben. Es ist schwer, alle möglichen Fälle zu decken und manchmal ist es unnötig, dies zu tun.

Ich habe NaN !== NaN sowie zirkuläre Abhängigkeiten.

https://github.com/ryancat/simple-deep-equal/blob/master/index.js

Answer 2

Ich habe eine Methode implementiert, die zwei jsons nimmt und prüft, ob ihre Schlüssel die gleichen Werte mit Rekursion haben. Ich habe weitere Frage um dieses Problem zu lösen.

const arraysEqual = (a, b) => {
    if (a === b)
        return true;
    if (a === null || b === null)
        return false;
    if (a.length !== b.length)
        return false;

    // If you don't care about the order of the elements inside
    // the array, you should sort both arrays here.

    for (let i = 0; i < a.length; ++i) {
        if (a[i] !== b[i])
            return false;
    }
    return true;
};

const jsonsEqual = (a, b) => {

  if(typeof a !== 'object' || typeof b !== 'object')
      return false;

  if (Object.keys(a).length === Object.keys(b).length) { // if items have the same size
      let response = true;

      for (let key in a) {
          if (!b[key]) // if not key
              response = false;
          if (typeof a[key] !== typeof b[key]) // if typeof doesn't equals
              response = false;
          else {
              if (Array.isArray(a[key])) // if array
                  response = arraysEqual(a[key], b[key]);
              else if (typeof a[key] === 'object') // if another json
                  response = jsonsEqual(a[key], b[key]);
              else if (a[key] !== b[key])  // not equals
                  response = false;
          }
          if (!response) // return if one item isn't equal
              return false;
      }
  } else
      return false;

  return true;
};

const json1 = { 
  a: 'a', 
  b: 'asd', 
  c: [
    '1',
    2,
    2.5,
    '3', 
    {
      d: 'asd',
      e: [
        1.6,
        { 
          f: 'asdasd',
          g: '123'
        }
      ]
    }
  ],
  h: 1,
  i: 1.2,
};

const json2 = {
  a: 'nops',
  b: 'asd'
};

const json3 = { 
  a: 'h', 
  b: '484', 
  c: [
    3,
    4.5,
    '2ss', 
    {
      e: [
        { 
          f: 'asdasd',
          g: '123'
        }
      ]
    }
  ],
  h: 1,
  i: 1.2,
};

const result = jsonsEqual(json1,json2);
//const result = jsonsEqual(json1,json3);
//const result = jsonsEqual(json1,json1);

if(result) // is equal
  $('#result').text("Jsons are the same")
else
  $('#result').text("Jsons aren't equals")

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

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

Answer 3

Abhängig. Wenn die Reihenfolge der Schlüssel im Objekt nicht von Bedeutung ist und ich die Prototypen des besagten Objekts nicht kennen muss. Verwenden Sie immer die Arbeit zu tun.

const object = {};
JSON.stringify(object) === "{}" will pass but {} === "{}" will not

Answer 4

Hier ist eine Version des stringify Tricks, die weniger typisiert ist und in vielen Fällen für triviale JSON Datenvergleiche funktioniert.

var obj1Fingerprint = JSON.stringify(obj1).replace(/\{|\}/g,'').split(',').sort().join(',');
var obj2Fingerprint = JSON.stringify(obj2).replace(/\{|\}/g,'').split(',').sort().join(',');
if ( obj1Fingerprint === obj2Fingerprint) { ... } else { ... }

Answer 5

Das hängt davon ab, was Sie unter Gleichheit verstehen. Und deshalb liegt es an Ihnen als Entwickler der Klassen, deren Gleichheit zu definieren.

Es gibt einen Fall, in dem zwei Instanzen als "gleich" betrachtet werden, wenn sie auf denselben Speicherplatz zeigen, aber das ist nicht immer das, was man will. Wenn ich zum Beispiel eine Person-Klasse habe, möchte ich vielleicht zwei Person-Objekte als "gleich" betrachten, wenn sie denselben Nachnamen, Vornamen und dieselbe Sozialversicherungsnummer haben (auch wenn sie auf verschiedene Speicherplätze zeigen).

Andererseits können wir nicht einfach sagen, dass zwei Objekte gleich sind, wenn der Wert jedes ihrer Mitglieder gleich ist, denn manchmal will man das nicht. Mit anderen Worten: Für jede Klasse muss der Klassenentwickler definieren, welche Mitglieder die "Identität" der Objekte ausmachen, und einen geeigneten Gleichheitsoperator entwickeln (sei es durch Überladen des ==-Operators oder eine Gleichheitsmethode).

Die Aussage, dass zwei Objekte gleich sind, wenn sie den gleichen Hash haben, ist ein Ausweg. Allerdings muss man sich dann fragen, wie der Hash für jede Instanz berechnet wird. Um auf das obige Beispiel der Person zurückzukommen, könnten wir dieses System verwenden, wenn der Hash anhand der Werte der Felder Vorname, Nachname und Sozialversicherungsnummer berechnet würde. Darüber hinaus verlassen wir uns dann auf die Qualität der Hash-Methode (das ist ein großes Thema für sich, aber es genügt zu sagen, dass nicht alle Hashes gleich sind und schlechte Hash-Methoden zu mehr Kollisionen, die in diesem Fall falsche Treffer liefern würden).