Wie bestimme ich die Gleichheit für zwei JavaScript-Objekte?

Ein strikter Gleichheits - Operator werden Ihnen sagen , wenn zwei Objekttypen gleich sind. Gibt es jedoch eine Möglichkeit, festzustellen, ob zwei Objekte gleich sind, ähnlich wie beim Hash-Code Wert in Java?

Frage zum Stapelüberlauf Gibt es eine HashCode-Funktion in JavaScript? ähnelt dieser Frage, erfordert jedoch eine akademischere Antwort. Das obige Szenario zeigt, warum es notwendig wäre, eine zu haben, und ich frage mich, ob es eine gleichwertige Lösung gibt .

Die kurze Antwort

Die einfache Antwort lautet: Nein, es gibt keine generischen Mittel, um festzustellen, ob ein Objekt einem anderen in dem von Ihnen gemeinten Sinne gleich ist. Die Ausnahme ist, wenn Sie streng daran denken, dass ein Objekt typenlos ist.

Die lange Antwort

Das Konzept ist das einer Equals-Methode, bei der zwei verschiedene Instanzen eines Objekts verglichen werden, um anzuzeigen, ob sie auf einer Wertebene gleich sind. Es ist jedoch Sache des jeweiligen Typs, zu definieren, wie eine EqualsMethode implementiert werden soll. Ein iterativer Vergleich von Attributen mit primitiven Werten reicht möglicherweise nicht aus. Es kann durchaus Attribute geben, die nicht als Teil des Objektwerts betrachtet werden sollen. 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 obigen Fall cist es nicht wirklich wichtig zu bestimmen, ob zwei Instanzen von MyClass gleich sind, nur aundb sind wichtig. In manchen Fällenc kann dies zwischen den Instanzen variieren und ist beim Vergleich dennoch nicht signifikant.

Beachten Sie, dass dieses Problem auftritt, wenn Mitglieder selbst auch Instanzen eines Typs sein können und diese alle über ein Mittel zur Bestimmung der Gleichheit verfügen müssen.

Erschwerend kommt hinzu, dass in JavaScript die Unterscheidung zwischen Daten und Methode unscharf ist.

Ein Objekt kann auf eine Methode verweisen, die als Ereignishandler aufgerufen werden soll, und dies wird wahrscheinlich nicht als Teil seines 'Wertezustands' betrachtet. Während einem anderen Objekt durchaus eine Funktion zugewiesen werden kann, die eine wichtige Berechnung durchführt und dadurch diese Instanz von anderen unterscheidet, nur weil sie auf eine andere Funktion verweist.

Was ist mit einem Objekt, bei dem eine der vorhandenen Prototypmethoden von einer anderen Funktion überschrieben wird? Könnte es immer noch als gleichwertig mit einer anderen Instanz angesehen werden, dass es ansonsten identisch ist? Diese Frage kann nur in jedem Einzelfall für jeden Typ beantwortet werden.

Wie bereits erwähnt, wäre die Ausnahme ein streng typenloses Objekt. In diesem Fall ist die einzig sinnvolle Wahl ein iterativer und rekursiver Vergleich jedes Mitglieds. Selbst dann muss man sich fragen, was der 'Wert' einer Funktion ist.

Warum das Rad neu erfinden? Probieren Sie Lodash aus . Es hat eine Reihe von Must-Have-Funktionen wie isEqual () .

_.isEqual(object, other);

Jeder Schlüsselwert wird - genau wie in den anderen Beispielen auf dieser Seite - mithilfe von ECMAScript 5 und nativen Optimierungen brutal überprüft, sofern diese im Browser verfügbar sind.

Hinweis: Früher empfahl diese Antwort Underscore.js , aber lodash hat es besser gemacht, Fehler zu beheben und Probleme mit Konsistenz zu beheben.

Der Standard-Gleichheitsoperator in JavaScript für Objekte ergibt true, wenn sie sich auf denselben Speicherort im Speicher beziehen.

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

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

Wenn Sie einen anderen Gleichheitsoperator benötigen, müssen equals(other)Sie Ihren Klassen eine Methode oder ähnliches hinzufügen , und die Besonderheiten Ihrer Problemdomäne bestimmen, was genau dies bedeutet.

Hier ist ein Spielkartenbeispiel:

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

Wenn Sie in AngularJS arbeiten , ermittelt die angular.equalsFunktion, ob zwei Objekte gleich sind. In Ember.js verwenden isEqual.

• angular.equals- Weitere Informationen zu dieser Methode finden Sie in den Dokumenten oder in der Quelle . Es macht auch einen tiefen Vergleich bei Arrays.
• Ember.js isEqual- Weitere Informationen zu dieser Methode finden Sie in den Dokumenten oder in der Quelle . Es wird kein tiefer Vergleich für Arrays durchgeführt.

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>

Das ist meine Version. Es verwendet die neue Funktion Object.keys , die in ES5 eingeführt wird, sowie Ideen / Tests von + , + und + :

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

Wenn Sie eine JSON-Bibliothek verwenden, können Sie jedes Objekt als JSON codieren und dann die resultierenden Zeichenfolgen auf Gleichheit vergleichen.

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

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

HINWEIS: Obwohl diese Antwort in vielen Fällen funktioniert, ist sie aus verschiedenen Gründen problematisch, wie mehrere Personen in den Kommentaren hervorgehoben haben. In fast allen Fällen möchten Sie eine robustere Lösung finden.

Kurze funktionale deepEqualImplementierung:

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 Jibs Vorschlag und ES6-Pfeilfunktionen:

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

Versuchen Sie zu testen, ob zwei Objekte gleich sind? dh: ihre Eigenschaften sind gleich?

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

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

Möglicherweise müssen Sie Folgendes 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 könnte diese Funktion einiges an Optimierung und die Möglichkeit einer gründlichen Überprüfung (zur Behandlung verschachtelter Objekte) vertragen: var a = { foo : { fu : "bar" } } aber Sie haben die Idee.

Wie FOR hervorhob, müssen Sie dies möglicherweise für Ihre eigenen Zwecke anpassen, z. B.: Verschiedene Klassen haben möglicherweise unterschiedliche Definitionen von "gleich". Wenn Sie nur mit einfachen Objekten arbeiten, kann das oben Genannte ausreichen, andernfalls kann eine benutzerdefinierte MyClass.equals()Funktion der richtige Weg sein.

Wenn Sie eine tiefe Kopierfunktion zur Hand haben, können Sie den folgenden Trick verwenden , um noch verwendet werden, JSON.stringifywährend die Reihenfolge der Objekte in dieser Auswahl:

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

Demo: http://jsfiddle.net/CU3vb/3/

Begründung:

Da die Eigenschaften von obj1einzeln in den Klon kopiert werden, bleibt ihre Reihenfolge im Klon erhalten. Und wenn die Eigenschaften von obj2in den Klon kopiert obj1werden, werden ihre Ordnungen im Klon beibehalten , da bereits vorhandene Eigenschaften einfach überschrieben werden.

In Node.js können Sie das native verwenden require("assert").deepStrictEqual. Weitere Informationen: http://nodejs.org/api/assert.html

Zum Beispiel:

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

Ein weiteres Beispiel, das true/ falseanstelle von Fehlern zurückgibt :

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

Einfachste und logischste Lösungen zum Vergleichen von Objekten wie Objekt, Array, String, Int ...

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

Hinweis:

• Sie müssen val1und val2mit Ihrem Objekt ersetzen
• Für das Objekt müssen Sie für beide Seitenobjekte rekursiv (nach Schlüssel) sortieren

Ich verwende diese comparableFunktion, um Kopien meiner Objekte zu erstellen, die mit JSON vergleichbar sind:

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>

Ist praktisch in Tests (die meisten Test-Frameworks haben eine isFunktion). Z.B

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

Wenn ein Unterschied festgestellt wird, werden Zeichenfolgen protokolliert, wodurch Unterschiede erkennbar werden:

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

Hier ist eine Lösung in ES6 / ES2015, die einen funktionalen Ansatz verwendet:

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

Ich weiß nicht, ob jemand etwas Ähnliches gepostet hat, aber hier ist eine Funktion, die ich gemacht habe, um nach Objektgleichheiten zu suchen.

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, sodass es auch auf tiefe Gleichheit prüfen kann, wenn Sie es so nennen.

Für diejenigen unter Ihnen, die NodeJS verwenden, gibt es eine praktische Methode, die isDeepStrictEqualfür die native Util-Bibliothek aufgerufen wird, um dies zu erreichen.

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

ES6: Der Mindestcode, den ich dafür bekommen könnte, ist dieser. Es führt einen tiefen rekursiven Vergleich durch, indem alle Objekte stringifiziert werden. Die einzige Einschränkung besteht darin, dass keine Methoden oder Symbole verglichen werden.

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

Sie können _.isEqual(obj1, obj2)aus der Bibliothek underscore.js verwenden.

Hier ist ein Beispiel:

var stooge = {name: 'moe', luckyNumbers: [13, 27, 34]};
var clone  = {name: 'moe', luckyNumbers: [13, 27, 34]};
stooge == clone;
=> false
_.isEqual(stooge, clone);
=> true

Die offizielle Dokumentation finden Sie hier: http://underscorejs.org/#isEqual

Angenommen, die Reihenfolge der Eigenschaften im Objekt wird nicht geändert.

JSON.stringify () funktioniert für beide Objekttypen tief und nicht tief, wobei die Leistungsaspekte nicht sehr sicher sind:

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

Eine einfache Lösung für dieses Problem, die viele Menschen nicht erkennen, besteht darin, die JSON-Zeichenfolgen (pro Zeichen) zu sortieren. Dies ist normalerweise 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(''));
}

Eine weitere nützliche Sache bei dieser Methode ist, dass Sie Vergleiche filtern können, indem Sie eine "Ersetzer" -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 mit dem Namen "derp" verglichen:

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

Ich wollte nur meine Version des Objektvergleichs mit einigen es6-Funktionen beitragen. Eine Bestellung wird nicht berücksichtigt. Nachdem ich alle if / else's in ternary konvertiert habe, bin ich mit folgendem Ergebnis gekommen:

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;

        }
    )
}

Ich brauchte eine allgemeinere Objektvergleichsfunktion als veröffentlicht und habe mir Folgendes ausgedacht. Kritik geschätzt ...

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

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

npm install rus-diff

Verwendungszweck:

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 ein MongoDB-kompatibles {$rename:{...}, $unset:{...}, $set:{...}}Objekt zurückgegeben.

Ich stand vor dem gleichen Problem und beschloss, meine eigene Lösung zu schreiben. Da ich aber auch Arrays mit Objekten vergleichen möchte und umgekehrt, habe ich eine generische Lösung entwickelt. Ich habe beschlossen, die Funktionen zum Prototyp hinzuzufügen, aber man kann sie leicht in eigenständige Funktionen umschreiben. Hier ist der Code:

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

Dieser Algorithmus ist in zwei Teile unterteilt. Die Funktion equals selbst und eine Funktion zum Ermitteln des numerischen Index einer Eigenschaft in einem Array / Objekt. Die Suchfunktion wird nur benötigt, weil indexof nur Zahlen und Zeichenfolgen und keine Objekte findet.

Man kann es so nennen:

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

Die Funktion gibt entweder true oder false zurück, in diesem Fall true. Der Algorithmus ermöglicht auch den Vergleich zwischen sehr komplexen Objekten:

({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"]})

Das obere Beispiel gibt true zurück, obwohl die Eigenschaften eine andere Reihenfolge haben. Ein kleines Detail, auf das Sie achten sollten: Dieser Code sucht auch nach demselben Typ von zwei Variablen, sodass "3" nicht mit 3 identisch ist.

Ich sehe Spaghetti-Code-Antworten. Ohne die Verwendung von Bibliotheken von Drittanbietern ist dies sehr einfach.

Sortieren Sie zunächst die beiden Objekte nach Schlüssel und Schlüsselnamen.

let objectOne = { hey, you }
let objectTwo = { you, hey }

// If you really wanted you could make this recursive for deep sort.
const sortObjectByKeyname = (objectToSort) => {
    return Object.keys(objectToSort).sort().reduce((r, k) => (r[k] = objectToSort[k], r), {});
}

let objectOne = sortObjectByKeyname(objectOne)
let objectTwo = sortObjectByKeyname(objectTwo)

Verwenden Sie dann einfach eine Zeichenfolge, um sie zu vergleichen.

JSON.stringify(objectOne) === JSON.stringify(objectTwo)

Ich würde von Hashing oder Serialisierung abraten (wie die JSON-Lösung vorschlägt). Wenn Sie testen müssen, ob zwei Objekte gleich sind, müssen Sie definieren, was gleich bedeutet. Es kann sein, dass alle Datenelemente in beiden Objekten übereinstimmen, oder dass die Speicherorte übereinstimmen müssen (dh beide Variablen verweisen auf dasselbe Objekt im Speicher), oder dass nur ein Datenelement in jedem Objekt übereinstimmen muss.

Kürzlich habe ich ein Objekt entwickelt, dessen Konstruktor bei jeder Erstellung einer Instanz eine neue ID erstellt (beginnend mit 1 und inkrementierend um 1). Dieses Objekt verfügt über eine isEqual-Funktion, die diesen ID-Wert mit dem ID-Wert eines anderen Objekts vergleicht und true zurückgibt, wenn sie übereinstimmen.

In diesem Fall habe ich "gleich" so definiert, dass die ID-Werte übereinstimmen. Da jede Instanz eine eindeutige ID hat, kann dies verwendet werden, um die Idee durchzusetzen, dass übereinstimmende Objekte ebenfalls denselben Speicherort belegen. Obwohl das nicht nötig ist.

Es ist nützlich, zwei Objekte als gleich zu betrachten, wenn sie für alle Eigenschaften dieselben Werte und für alle verschachtelten Objekte und Arrays rekursiv haben. Ich betrachte auch die folgenden zwei Objekte als gleich:

var a = {p1: 1};
var b = {p1: 1, p2: undefined};

Ebenso können Arrays "fehlende" Elemente und undefinierte Elemente enthalten. Ich würde diese auch gleich behandeln:

var c = [1, 2];
var d = [1, 2, undefined];

Eine Funktion, die diese Definition von Gleichheit implementiert:

function isEqual(a, b) {
    if (a === b) {
        return true;
    }

    if (generalType(a) != generalType(b)) {
        return false;
    }

    if (a == b) {
        return true;
    }

    if (typeof a != 'object') {
        return false;
    }

    // null != {}
    if (a instanceof Object != b instanceof Object) {
        return false;
    }

    if (a instanceof Date || b instanceof Date) {
        if (a instanceof Date != b instanceof Date ||
            a.getTime() != b.getTime()) {
            return false;
        }
    }

    var allKeys = [].concat(keys(a), keys(b));
    uniqueArray(allKeys);

    for (var i = 0; i < allKeys.length; i++) {
        var prop = allKeys[i];
        if (!isEqual(a[prop], b[prop])) {
            return false;
        }
    }
    return true;
}

Quellcode (einschließlich der Hilfsfunktionen generalType und uniqueArray): Unit Test und Test Runner hier .

Ich mache mit dieser Funktion folgende Annahmen:

1. Sie steuern die Objekte, die Sie vergleichen, und Sie haben nur primitive Werte (dh keine verschachtelten Objekte, Funktionen usw.).
2. Ihr Browser unterstützt Object.keys .

Dies sollte als Demonstration einer einfachen Strategie betrachtet werden.

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

Dies ist eine Ergänzung für alle oben genannten, kein Ersatz. Wenn Sie Objekte mit flachem Vergleich schnell vergleichen müssen, ohne zusätzliche rekursive Fälle überprüfen zu müssen. Hier ist ein Schuss.

Dies ist vergleichbar mit: 1) Gleichheit der Anzahl der eigenen Eigenschaften, 2) Gleichheit der Schlüsselnamen, 3) wenn bCompareValues ​​== true, Gleichheit der entsprechenden Eigenschaftswerte und ihrer Typen (dreifache Gleichheit)

var shallowCompareObjects = function(o1, o2, bCompareValues) {
    var s, 
        n1 = 0,
        n2 = 0,
        b  = true;

    for (s in o1) { n1 ++; }
    for (s in o2) { 
        if (!o1.hasOwnProperty(s)) {
            b = false;
            break;
        }
        if (bCompareValues && o1[s] !== o2[s]) {
            b = false;
            break;
        }
        n2 ++;
    }
    return b && n1 == n2;
}

Zum Vergleichen von Schlüsseln für Objektinstanzen mit einfachen Schlüssel / Wert-Paaren verwende ich:

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

Sobald die Schlüssel verglichen sind, reicht eine einfache zusätzliche for..inSchleife aus.

Die Komplexität ist O (N * N), wobei N die Anzahl der Schlüssel ist.

Ich hoffe / vermute, dass Objekte, die ich definiere, nicht mehr als 1000 Eigenschaften enthalten ...

Ich weiß, dass dies ein bisschen alt ist, aber ich möchte eine Lösung hinzufügen, die ich für dieses Problem gefunden habe. Ich hatte ein Objekt und wollte wissen, wann sich seine Daten geändert haben. "etwas ähnliches wie Object.observe" und was ich getan habe war:

function checkObjects(obj,obj2){
   var values = [];
   var keys = [];
   keys = Object.keys(obj);
   keys.forEach(function(key){
      values.push(key);
   });
   var values2 = [];
   var keys2 = [];
   keys2 = Object.keys(obj2);
   keys2.forEach(function(key){
      values2.push(key);
   });
   return (values == values2 && keys == keys2)
}

Dies hier kann dupliziert werden und ein anderer Satz von Arrays erstellt werden, um die Werte und Schlüssel zu vergleichen. Dies ist sehr einfach, da sie jetzt Arrays sind und false zurückgeben, wenn Objekte unterschiedliche Größen haben.