Jak ustalić równość dla dwóch obiektów JavaScript?

Operator ścisłej równości powie ci, czy dwa typy obiektów są równe. Czy istnieje jednak sposób, aby stwierdzić, czy dwa obiekty są równe, podobnie jak wartość kodu skrótu w Javie?

Pytanie o przepełnienie stosu Czy w JavaScript jest jakaś funkcja hashCode? jest podobny do tego pytania, ale wymaga bardziej akademickiej odpowiedzi. Powyższy scenariusz pokazuje, dlaczego taki miałby być konieczny, i zastanawiam się, czy istnieje jakieś równoważne rozwiązanie .

Krótka odpowiedź

Prosta odpowiedź brzmi: nie, nie ma ogólnych sposobów na ustalenie, że obiekt jest równy drugiemu w sensie, który masz na myśli. Wyjątkiem jest sytuacja, gdy myślisz ściśle o tym, że obiekt nie jest typem.

Długa odpowiedź

Chodzi o metodę Equals, która porównuje dwa różne wystąpienia obiektu, aby wskazać, czy są one równe na poziomie wartości. Jednak to od konkretnego typu zależy określenie Equalssposobu implementacji metody. Iteracyjne porównanie atrybutów, które mają prymitywne wartości, może nie wystarczyć, mogą istnieć atrybuty, których nie należy uważać za część wartości obiektu. Na przykład,

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

W powyższym przypadku cnie jest naprawdę ważne ustalenie, czy jakieś dwa wystąpienia MyClass są równe, tylko ai bsą ważne. W niektórych przypadkach cmogą się różnić między instancjami, ale nie są znaczące podczas porównania.

Uwaga: ta kwestia ma zastosowanie, gdy członkowie mogą być również instancjami danego typu i każdy z nich musiałby mieć środki do ustalenia równości.

Jeszcze bardziej skomplikowane jest to, że w JavaScript rozróżnia się rozróżnienie między danymi a metodą.

Obiekt może odwoływać się do metody, która ma zostać wywołana jako moduł obsługi zdarzeń, i prawdopodobnie nie będzie to uważane za część jego „stanu wartości”. Podczas gdy do innego obiektu można również przypisać funkcję, która wykonuje ważne obliczenia, a tym samym odróżnia ten przypadek od innych tylko dlatego, że odwołuje się do innej funkcji.

Co z obiektem, który ma jedną z istniejących metod prototypowych zastąpioną przez inną funkcję? Czy nadal można uznać to za równe innej instancji, która w przeciwnym razie byłaby identyczna? Na to pytanie można odpowiedzieć tylko w każdym konkretnym przypadku dla każdego rodzaju.

Jak wspomniano wcześniej, wyjątkiem byłby obiekt całkowicie bez typu. W takim przypadku jedynym rozsądnym wyborem jest iteracyjne i rekurencyjne porównanie każdego członka. Nawet wtedy trzeba zapytać, jaka jest „wartość” funkcji?

Po co wymyślać koło ponownie? Wypróbuj Lodash . Ma wiele niezbędnych funkcji, takich jak isEqual () .

_.isEqual(object, other);

Brutalna siła sprawdzi każdą kluczową wartość - podobnie jak inne przykłady na tej stronie - używając ECMAScript 5 i natywnych optymalizacji, jeśli są one dostępne w przeglądarce.

Uwaga: poprzednio ta odpowiedź zalecała Underscore.js , ale lodash lepiej radził sobie z naprawianiem błędów i spójnym rozwiązywaniem problemów.

Domyślny operator równości w JavaScript dla Objects daje true, gdy odnoszą się do tej samej lokalizacji w pamięci.

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

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

Jeśli potrzebujesz innego operatora równości, musisz dodać equals(other)metodę lub coś podobnego do swoich klas, a specyfika domeny problemu określi, co to dokładnie oznacza.

Oto przykład karty do gry:

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

Jeśli pracujesz w AngularJS , angular.equalsfunkcja określi, czy dwa obiekty są równe. W Ember.js użyj isEqual.

• angular.equals- Zobacz dokumentację lub źródło, aby uzyskać więcej informacji na temat tej metody. Dokładnie porównuje również tablice.
• Ember.js isEqual- więcej informacji na temat tej metody można znaleźć w dokumentacji lub źródle . Nie dokonuje głębokiego porównania tablic.

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>

To jest moja wersja. Korzysta z nowej funkcji Object.keys, która została wprowadzona w ES5, oraz pomysłów / testów z + , + i + :

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

Jeśli używasz biblioteki JSON, możesz zakodować każdy obiekt jako JSON, a następnie porównać otrzymane ciągi pod kątem równości.

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

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

UWAGA: Chociaż odpowiedź ta zadziała w wielu przypadkach, jak zauważyło kilka osób w komentarzach, jest ona problematyczna z różnych powodów. W większości przypadków będziesz chciał znaleźć bardziej niezawodne rozwiązanie.

Krótkie deepEqualwdrożenie funkcjonalne :

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

Edycja : wersja 2, używając sugestii wysięgnika i funkcji strzałek ES6:

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

Czy próbujesz sprawdzić, czy dwa obiekty są równe? tj .: ich właściwości są równe?

W takim przypadku prawdopodobnie zauważysz tę sytuację:

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

być może będziesz musiał zrobić coś takiego:

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

Oczywiście ta funkcja mogłaby przydać się z dość dużą optymalizacją i możliwością głębokiego sprawdzania (do obsługi zagnieżdżonych obiektów: var a = { foo : { fu : "bar" } } ale masz pomysł.

Jak wskazano na FOR, być może będziesz musiał dostosować to do własnych celów, np .: różne klasy mogą mieć różne definicje „równości”. Jeśli pracujesz tylko z prostymi obiektami, powyższe może wystarczyć, w przeciwnym razie MyClass.equals()możesz skorzystać z funkcji niestandardowej .

Jeśli masz pod ręką funkcję głębokiego kopiowania, możesz skorzystać z następującej sztuczki, aby nadal używać JSON.stringify, dopasowując kolejność właściwości:

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/

Racjonalne uzasadnienie:

Ponieważ właściwości obj1są kopiowane do klonu jeden po drugim, ich kolejność w klonie zostanie zachowana. A kiedy właściwości obj2zostaną skopiowane do klonu, ponieważ właściwości już istniejące w obj1zostaną po prostu nadpisane, ich zamówienia w klonie zostaną zachowane.

W Node.js możesz użyć jego natywnego require("assert").deepStrictEqual. Więcej informacji: http://nodejs.org/api/assert.html

Na przykład:

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

Kolejny przykład, który zwraca true/ falsezamiast zwraca błędy:

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

Najprostsze i logiczne rozwiązania do porównywania wszystkiego jak Object, Array, String, Int ...

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

Uwaga:

• musisz wymienić val1iz val2Twoim Obiektem
• dla obiektu musisz sortować (według klucza) rekurencyjnie dla obu obiektów bocznych

Używam tej comparablefunkcji do tworzenia kopii moich obiektów, które są porównywalne z JSON:

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>

Przydaje się w testach (większość frameworków testowych ma swoją isfunkcję). Na przykład

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

W przypadku wychwycenia różnicy zapisywane są ciągi, dzięki czemu różnice są widoczne:

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

Oto rozwiązanie w ES6 / ES2015 wykorzystujące podejście funkcjonalne:

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 dostępne tutaj

Nie wiem, czy ktoś opublikował coś podobnego do tego, ale oto funkcja, którą sprawdziłem pod kątem równości obiektów.

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

Ponadto jest rekurencyjny, więc może również sprawdzać głęboką równość, jeśli tak to nazywacie.

Dla tych, którzy używają NodeJS, istnieje wygodna metoda wywoływana isDeepStrictEqualw natywnej bibliotece Util, która może to osiągnąć.

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: Oto minimalny kod, który mógłbym zrobić. Dokonuje głębokiego porównania rekurencyjnie poprzez stritowanie wszystkich obiektów, jedynym ograniczeniem jest brak metod lub porównywanie symboli.

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

możesz użyć _.isEqual(obj1, obj2)z biblioteki underscore.js.

Oto przykład:

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

Zobacz oficjalną dokumentację tutaj: http://underscorejs.org/#isEqual

Zakładając, że kolejność właściwości w obiekcie nie ulega zmianie.

JSON.stringify () działa na głębokie i nie głębokie oba typy obiektów, niezbyt pewny aspektów wydajnościowych:

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

Prostym rozwiązaniem tego problemu, którego wiele osób nie zdaje sobie sprawy, jest sortowanie ciągów JSON (według znaków). Jest to również zwykle szybsze niż w przypadku innych wymienionych tutaj rozwiązań:

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

Kolejną przydatną rzeczą w tej metodzie jest to, że możesz filtrować porównania, przekazując funkcję „zamiennika” do funkcji JSON.stringify ( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON / stringify # Example_of_using_replacer_parameter ). Poniższe porównuje tylko wszystkie klucze obiektów o nazwie „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;
});

Chciałem tylko dodać moją wersję porównania obiektów wykorzystującą niektóre funkcje es6. Nie uwzględnia zamówienia. Po konwersji wszystkich if / else na trójkę przyszedłem z następującymi elementami:

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;

        }
    )
}

Potrzebując bardziej ogólnej funkcji porównywania obiektów niż wcześniej napisałem, przygotowałem następujące. Doceniona krytyka ...

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

Jeśli porównujesz obiekty JSON, możesz użyć https://github.com/mirek/node-rus-diff

npm install rus-diff

Stosowanie:

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

Jeśli dwa obiekty są różne, {$rename:{...}, $unset:{...}, $set:{...}}zwracany jest obiekt podobny do MongoDB .

Napotkałem ten sam problem i postanowiłem napisać własne rozwiązanie. Ale ponieważ chcę również porównywać tablice z obiektami i odwrotnie, stworzyłem ogólne rozwiązanie. Postanowiłem dodać funkcje do prototypu, ale można łatwo przepisać je do samodzielnych funkcji. Oto kod:

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

Ten algorytm jest podzielony na dwie części; Sama funkcja równa się i funkcja znajdująca indeks numeryczny właściwości w tablicy / obiekcie. Funkcja wyszukiwania jest potrzebna tylko dlatego, że indexof znajduje tylko liczby i ciągi znaków, a nie żadnych obiektów.

Można to tak nazwać:

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

Funkcja zwraca true lub false, w tym przypadku true. Algorytm pozwala również na porównanie bardzo złożonych obiektów:

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

Górny przykład zwróci wartość true, nawet jeśli właściwości mają inną kolejność. Jeden mały szczegół, na który należy zwrócić uwagę: ten kod sprawdza również ten sam typ dwóch zmiennych, więc „3” to nie to samo co 3.

Widzę odpowiedzi na kod spaghetti. Bez korzystania z bibliotek stron trzecich jest to bardzo łatwe.

Najpierw posortuj dwa obiekty według klucza ich nazw kluczy.

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)

Następnie po prostu użyj ciągu znaków, aby je porównać.

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

Odradzam mieszanie lub serializację (jak sugerują rozwiązania JSON). Jeśli musisz sprawdzić, czy dwa obiekty są równe, musisz zdefiniować, co oznacza równość. Może się zdarzyć, że wszystkie elementy danych w obu obiektach będą pasować, lub może być tak, że lokalizacje pamięci muszą się zgadzać (co oznacza, że ​​obie zmienne odnoszą się do tego samego obiektu w pamięci), lub może być tak, że tylko jeden element danych w każdym obiekcie musi pasować.

Ostatnio opracowałem obiekt, którego konstruktor tworzy nowy identyfikator (zaczynając od 1 i zwiększając o 1) za każdym razem, gdy tworzona jest instancja. Ten obiekt ma funkcję isEqual, która porównuje tę wartość id z wartością id innego obiektu i zwraca wartość true, jeśli są one zgodne.

W takim przypadku zdefiniowałem „równy” jako oznaczający, że wartości id są zgodne. Biorąc pod uwagę, że każda instancja ma unikalny identyfikator, można to wykorzystać do wymuszenia przekonania, że ​​pasujące obiekty również zajmują to samo miejsce w pamięci. Chociaż nie jest to konieczne.

Przydatne jest uznanie dwóch obiektów za równe, jeśli mają wszystkie takie same wartości dla wszystkich właściwości i rekurencyjnie dla wszystkich zagnieżdżonych obiektów i tablic. Uważam również następujące dwa obiekty za równe:

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

Podobnie tablice mogą mieć „brakujące” elementy i niezdefiniowane elementy. Traktowałbym je również tak samo:

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

Funkcja, która implementuje tę definicję równości:

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

Kod źródłowy (w tym funkcje pomocnicze, generalType i uniqueArray): Test jednostkowy i Test Runner tutaj .

Za pomocą tej funkcji przyjmuję następujące założenia:

1. Kontrolujesz porównywane obiekty i masz tylko prymitywne wartości (tj. Nie zagnieżdżone obiekty, funkcje itp.).
2. Twoja przeglądarka obsługuje Object.keys .

Należy to potraktować jako demonstrację prostej strategii.

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

Jest to dodatek do wszystkich powyższych, a nie zamiennik. Jeśli chcesz szybko porównać obiekty bez konieczności sprawdzania dodatkowych przypadków rekurencyjnych. Oto strzał.

Dla porównania: 1) Równość liczby własnych właściwości, 2) Równość nazw kluczy, 3) jeśli bCompareValues ​​== true, Równość odpowiadających wartości właściwości i ich typów (potrójna równość)

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

Do porównywania kluczy dla instancji obiektów prostych par klucz / wartość używam:

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

Po porównaniu kluczy wystarczy zwykła dodatkowa for..inpętla.

Złożoność to O (N * N), a N to liczba kluczy.

Mam nadzieję, że obiekty, które zdefiniuję, nie będą zawierać więcej niż 1000 właściwości ...

Wiem, że to trochę stare, ale chciałbym dodać rozwiązanie, które wymyśliłem dla tego problemu. Miałem obiekt i chciałem wiedzieć, kiedy zmieniły się jego dane. „coś podobnego do Object.observe” i to, co zrobiłem, to:

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

Można to tutaj powielić i stworzyć inny zestaw tablic, aby porównać wartości i klucze. Jest to bardzo proste, ponieważ są teraz tablicami i zwrócą wartość false, jeśli obiekty mają różne rozmiary.