Wie, um zu bestimmen, Gleichheit für zwei JavaScript-Objekte?

Die kurze Antwort

Die einfache Antwort ist: Nein, es gibt keine generische Mittel zu bestimmen, dass ein Objekt gleich einem anderen in den Sinn, meinen Sie. Die Ausnahme ist, wenn Sie streng denken an ein Objekt typeless.

Die lange Antwort

Konzept ist, dass der Equals-Methode vergleicht zwei unterschiedliche Instanzen eines Objekts anzugeben, ob Sie gleich sind an Wert-Ebene. Allerdings ist es bis zu dem bestimmten Typ zu definieren, wie ein Equals Methode implementiert werden sollte. Ein iterativer Vergleich der Attribute mit primitiven Werten kann nicht genug sein, kann es durchaus sein, Attribute, die nicht als Teil des Objekts Wert. Zum Beispiel,

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

In diesem oben genannten Fall, der c ist nicht wirklich wichtig, um zu bestimmen, ob zwei Instanzen von MyClass sind gleich, nur a und b wichtig sind. In einigen Fällen c variieren zwischen den Instanzen und noch nicht signifikant beim Vergleich.

Hinweis: dieses Problem gilt, wenn Mitglieder können sich auch Instanzen von a geben und diese wäre all das benötigt, um ein Mittel zur Bestimmung der Geschlechter.

Weiter zu verkomplizieren, ist, dass in JavaScript die Unterscheidung zwischen Daten und Methode verwischt ist.

Ein Objekt-Referenz eine Methode, die aufgerufen wird, wenn ein event-handler, und dieser würde wahrscheinlich nicht als Teil des "value-Staat". In der Erwägung, dass ein anderes Objekt kann auch eine Funktion zugeordnet ist, führt eine wichtige Berechnungs-und dabei macht dieses Beispiel unterscheidet sich von anderen, einfach weil es verweist auf eine andere Funktion.

Was über ein Objekt, eine seiner bestehenden Prototypen Methoden überschrieben durch eine andere Funktion? Könnte es dann noch als gleich zu einem anderen Beispiel, dass es ansonsten identisch? Diese Frage kann nur beantwortet werden, in dem für jeden spezifischen Fall für jeden Typ.

Wie bereits erwähnt, die Ausnahme wäre ein streng typeless Objekt. In dem Fall die einzig sinnvolle Wahl ist ein iterativer und rekursiver Vergleich der einzelnen member. Auch dann ist zu Fragen, was ist der 'Wert' einer Funktion?

InformationsquelleAutor AnthonyWJones

Den Standard-Gleichheits-operator in JavaScript Objekte ergibt true, wenn Sie sich auf der gleichen Position im Speicher.

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

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

Wenn Sie benötigen eine andere Gleichheits-operator müssen Sie eine equals(other) - Methode, oder etwas ähnliches, um Ihre Klassen und die Einzelheiten der problem domain wird bestimmen, was genau das bedeutet.

Hier ist eine Spielkarte Beispiel:

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

InformationsquelleAutor Daniel X Moore

Kurze funktionelle deepEqual Umsetzung:

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

Bearbeiten: version 2, mit jib ' s Vorschlag und ES6 Pfeil-Funktionen:

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

InformationsquelleAutor atmin

Sind Sie versuchen, um zu testen, ob zwei Objekte gleich? dh: Ihre Eigenschaften sind gleich?

Wenn dies der Fall ist, werden Sie wahrscheinlich bemerkt haben, diese situation:

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

haben Sie vielleicht etwas wie das hier tun:

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

Offensichtlich, dass die Funktion könnte tun, mit ein bisschen Optimierung, und die Fähigkeit zu tun, tief-Prüfung (zu Griff verschachtelte Objekte: var a = { foo : { fu : "bar" } }), aber Sie bekommen die Idee.

Als FÜR hingewiesen, die Sie möglicherweise anpassen müssen, um diese für Ihre eigenen Zwecke, zB: verschiedene Klassen haben unterschiedliche Definitionen von "gleich". Wenn Sie gerade arbeiten mit einfachen Objekten, die über ausreichen kann, andernfalls wird eine benutzerdefinierte MyClass.equals() - Funktion kann der Weg zu gehen.

InformationsquelleAutor nickf

In Node.js haben, können Sie seine native require("assert").deepEqual. Mehr info:
http://nodejs.org/api/assert.html

Beispiel:

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

Ein weiteres Beispiel, das gibt true /false anstatt Fehler:

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

InformationsquelleAutor Rafael Xavier

Ich weiß nicht, ob jemand etwas ähnliches gepostet, aber hier ist eine Funktion, die ich durchgeführt, um zu überprüfen für die Objekt-Gleichheit.

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 macht es rekursiv, so kann es auch überprüfen, für Tiefe Gleichheit, wenn es das ist, was Sie es nennen.

InformationsquelleAutor Zac

Eine einfache Lösung für dieses Problem, die viele Menschen nicht wissen, ist das Sortieren der JSON-strings (pro Charakter). Dies ist in der Regel auch schneller als die anderen Lösungen, die hier erwähnt werden:

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

Andere nützliche Sache über diese Methode können Sie einen filter für Vergleiche mit der übergabe eines "replacer" - Funktion, um die JSON.stringify Funktionen (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#Example_of_using_replacer_parameter). Im folgenden wird nur vergleichen Sie alle Objekte, Schlüssel namens "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;
});

InformationsquelleAutor th317erd

Würd ich abraten hashing oder Serialisierung (JSON Lösung vorschlagen). Wenn Sie brauchen, um zu testen, ob zwei Objekte gleich sind, dann werden Sie brauchen, um zu definieren, was gleich bedeutet. Es könnte sein, dass alle Daten, die Mitglieder beider Objekte übereinstimmen, oder es könnte sein, dass müssen die Speicheradressen übereinstimmen (d.h. beide Variablen verweisen auf das gleiche Objekt im Speicher), oder kann sein, dass nur ein Daten-member in jedem Objekt müssen übereinstimmen.

Kürzlich entwickelte ich ein Objekt, dessen Konstruktor erstellt eine neue id (beginnend mit 1 und Erhöhung um 1) jedes mal, wenn eine Instanz erstellt wird. Dieses Objekt hat eine isEqual-Funktion vergleicht den id-Wert mit dem Wert der id eines anderen Objekts und gibt true zurück, wenn Sie übereinstimmen.

In diesem Fall habe ich definiert "gleich" im Sinne von das die id-Werte übereinstimmen. Da jede Instanz hat eine eindeutige id, diese könnte verwendet werden, um die Durchsetzung der Idee, dass passende Objekte auch belegen den gleichen Speicherbereich. Obwohl, dass ist nicht notwendig.

InformationsquelleAutor Bernard Igiri

Wenn Sie vergleichen JSON-Objekte, die Sie verwenden können, https://github.com/mirek/node-rus-diff

npm install rus-diff

Verwendung:

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

Wenn zwei Objekte unterschiedlich sind, wird eine MongoDB-kompatible {$rename:{...}, $unset:{...}, $set:{...}} wie Objekt zurückgegeben.

InformationsquelleAutor Mirek Rusin

Wollte nur beitragen, meine version von Objekten-Vergleich unter Verwendung von ein paar es6-features. Es doesn ' T nehmen eine Bestellung zu berücksichtigen. Nach der Konvertierung werden alle if/else ist zu ternären ich habe kam mit folgenden:

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;

        }
    )
}

InformationsquelleAutor Egor Litvinchuk

Mache ich die folgenden Annahmen, die mit dieser Funktion:

1. Steuern Sie die Objekte, die Sie vergleichen und Sie haben nur primitive Werte (dh. nicht verschachtelte Objekte, Funktionen, etc.).
2. Ihr browser die Unterstützung für Objekt.Schlüssel.

Diese sollten behandelt werden, als eine demonstration von einer einfachen Strategie.

/**
 * Checks the equality of two objects that contain primitive values. (ie. no nested objects, functions, etc.)
 * @param {Object} object1
 * @param {Object} object2
 * @param {Boolean} [order_matters] Affects the return value of unordered objects. (ex. {a:1, b:2} and {b:2, a:1}).
 * @returns {Boolean}
 */
function isEqual( object1, object2, order_matters ) {
    var keys1 = Object.keys(object1),
        keys2 = Object.keys(object2),
        i, key;

    //Test 1: Same number of elements
    if( keys1.length != keys2.length ) {
        return false;
    }

    //If order doesn't matter isEqual({a:2, b:1}, {b:1, a:2}) should return true.
    //keys1 = Object.keys({a:2, b:1}) = ["a","b"];
    //keys2 = Object.keys({b:1, a:2}) = ["b","a"];
    //This is why we are sorting keys1 and keys2.
    if( !order_matters ) {
        keys1.sort();
        keys2.sort();
    }

    //Test 2: Same keys
    for( i = 0; i < keys1.length; i++ ) {
        if( keys1[i] != keys2[i] ) {
            return false;
        }
    }

    //Test 3: Values
    for( i = 0; i < keys1.length; i++ ) {
        key = keys1[i];
        if( object1[key] != object2[key] ) {
            return false;
        }
    }

    return true;
}

InformationsquelleAutor Aldo Fregoso

Vergleichen-Tasten für einfache Schlüssel/Wert-Paare-Objekt-Instanzen, die ich benutze:

function compareKeys(r1, r2) {
    var nloops = 0, score = 0;
    for(k1 in r1) {
        for(k2 in r2) {
            nloops++;
            if(k1 == k2)
                score++; 
        }
    }
    return nloops == (score * score);
};

Einmal die Tasten sind im Vergleich, eine einfache zusätzliche for..in Schleife ist genug.

Komplexität ist O(N*N) mit N ist die Anzahl der Tasten.

Ich hoffe/denke, Objekte definiere ich nicht halten mehr als 1000 Eigenschaften...

InformationsquelleAutor Hefeust CORTES

Hier eine version des stringify trick, die weniger Tippen und funktioniert in vielen Fällen für trivial JSON-Daten Vergleiche.

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

InformationsquelleAutor EJW