Як визначити рівність для двох об’єктів JavaScript?

Оператор суворої рівності скаже вам, якщо два типи об'єктів рівні. Однак чи існує спосіб визначити, чи два об'єкти рівні, як значення хеш-коду на Java?

Питання про переповнення стека Чи є в JavaScript функція hashCode? подібне до цього питання, але вимагає більш академічної відповіді. Наведений вище сценарій демонструє, чому це було б потрібно, і мені цікаво, чи є рівнозначне рішення .

Коротка відповідь

Проста відповідь: Ні, немає загальних засобів, щоб визначити, що об'єкт дорівнює іншому в тому сенсі, який ви маєте на увазі. Виняток - коли ви суворо думаєте про те, що об'єкт є безтиповим.

Довга відповідь

Концепція - це метод рівняння, який порівнює два різних екземпляри об'єкта, щоб вказати, чи рівні вони на рівні значень. Однак визначити, як Equalsметод слід реалізувати , залежить від конкретного типу . Ітераційне порівняння атрибутів, які мають примітивні значення, може бути недостатньою, можливо, можуть бути атрибути, які не слід вважати частиною об'єктного значення. Наприклад,

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

У цьому вище випадку cне дуже важливо визначати, чи будь-які два екземпляри MyClass рівні, лише aі bє важливими. У деяких випадках cможе відрізнятися між окремими прикладами, але ще не мати суттєвого значення для порівняння.

Зауважте, ця проблема застосовується, коли самі члени також можуть бути типовими екземплярами, і всі вони повинні мати засоби визначення рівності.

Подальше ускладнює те, що в JavaScript різниця між даними та методом розмита.

Об'єкт може посилатися на метод, який повинен називатися обробником подій, і це, швидше за все, не вважатиметься частиною його «стану значень». Тоді як іншому об'єкту цілком може бути призначена функція, яка виконує важливий обчислення, і тим самим робить цей екземпляр відмінним від інших просто тому, що він посилається на іншу функцію.

А що з об’єктом, який має один із існуючих методів прототипу, замінений на іншу функцію? Чи все-таки можна вважати рівним інший екземпляр, який інакше ідентичний? На це питання можна відповісти лише в кожному конкретному випадку для кожного типу.

Як було сказано раніше, виняток становитиме суто безтиповий об'єкт. У цьому випадку єдиним розумним вибором є ітеративне та рекурсивне порівняння кожного члена. Вже тоді потрібно запитати, яке «значення» функції?

Навіщо винаходити колесо? Спробуйте Лодаш . Він має ряд обов'язкових функцій, таких як isEqual () .

_.isEqual(object, other);

Це змусить перевірити кожне ключове значення - як і інші приклади на цій сторінці - використовуючи ECMAScript 5 та вбудовані оптимізації, якщо вони доступні у веб-переглядачі.

Примітка: Раніше ця відповідь рекомендувала Underscore.js , але lodash зробив кращу роботу з виправлення помилок та вирішення проблем із послідовністю.

Оператор рівності за замовчуванням в JavaScript для об’єктів дає істину, коли вони посилаються на одне і те ж місце в пам'яті.

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

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

Якщо вам потрібен інший оператор рівності, вам потрібно буде додати equals(other)метод або щось подібне до своїх класів, а специфіка вашого проблемного домену визначатиме, що саме це означає.

Ось приклад ігрової карти:

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

Якщо ви працюєте в AngularJS , angular.equalsфункція визначатиме, чи два об'єкти рівні. У Ember.js використання isEqual.

• angular.equals- Докладніше про цей метод див. У документах або джерелах . Це також глибоке порівняння на масивах.
• Ember.js isEqual- Докладніше про цей метод див. У документах або джерелах . Це не робить глибокого порівняння на масивах.

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>

Це моя версія. Він використовує нову функцію Object.keys, яка вводиться в ES5 та ідеї / тести з + , + та + :

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

Якщо ви використовуєте бібліотеку JSON, ви можете кодувати кожен об'єкт як JSON, а потім порівняти отримані рядки для рівності.

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

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

ПРИМІТКА. Хоча ця відповідь спрацює у багатьох випадках, як кілька людей зазначили у коментарях, вона є проблематичною з різних причин. В більшості випадків ви хочете знайти більш надійне рішення.

Коротка функціональна deepEqualреалізація:

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

Редагувати : версія 2, використовуючи пропозицію jib та стрілки 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);
}

Ви намагаєтесь перевірити, чи два об'єкти рівні? тобто: їх властивості рівні?

Якщо це так, ви, ймовірно, помітили таку ситуацію:

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

можливо, вам доведеться зробити щось подібне:

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

Очевидно, що ця функція могла б зробити досить оптимізацією та можливістю глибокої перевірки (для обробки вкладених об'єктів:), var a = { foo : { fu : "bar" } }але ви отримаєте ідею.

Як зазначалося ДЛЯ, можливо, вам доведеться адаптувати це для власних цілей, наприклад: різні класи можуть мати різні визначення "рівних". Якщо ви просто працюєте з простими об'єктами, вищезазначеного може бути достатньо, інакше спеціальна MyClass.equals()функція може бути дорогою.

Якщо у вас є функція глибокої копіювання, ви можете використовувати наступний трюк, який все ще використовуватимуть, дотримуючись JSON.stringifyпорядку властивостей:

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

Демонстрація: http://jsfiddle.net/CU3vb/3/

Обгрунтування:

Оскільки властивості obj1атрибутуються в клон по черзі, їх порядок у клоні буде збережено. І коли властивості obj2копіюються в клон, оскільки властивості, які вже існують у obj1, просто будуть перезаписані, їхні порядки в клоні будуть збережені.

У Node.js ви можете використовувати його рідний require("assert").deepStrictEqual. Більше інформації: http://nodejs.org/api/assert.html

Наприклад:

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

Ще один приклад, який повертає true/ falseзамість повертає помилки:

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

Найпростіші та логічні рішення для порівняння всього, наприклад, об’єкта, масиву, рядків, внутрішніх ...

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

Примітка:

• вам потрібно замінити val1і val2своїм об’єктом
• для об'єкта потрібно сортувати (за ключем) рекурсивно для обох бічних об'єктів

Я використовую цю comparableфункцію для створення копій моїх об'єктів, порівняних з 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>

Корисний тест (більшість тестових рамок мають isфункцію). Напр

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

Якщо різниця виявлена, рядки реєструються, що робить відмінності помітними:

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

Тут є рішення у ES6 / ES2015, використовуючи підхід у функціональному стилі:

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

демонстрація доступна тут

Я не знаю, чи хтось розмістив щось подібне до цього, але ось функція, яку я зробив для перевірки рівності об'єкта.

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

Крім того, він є рекурсивним, тому він також може перевірити наявність глибокої рівності, якщо це так ви називаєте.

Для тих, хто використовує NodeJS, існує зручний метод, який називається isDeepStrictEqualу рідній бібліотеці Util, який може цього досягти.

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: Мінімальний код, який я міг би зробити, це такий. Це робиться глибоке порівняння рекурсивно шляхом строфікації всіх об'єктів, єдиним обмеженням є відсутність методів чи символів порівняння.

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

ви можете використовувати _.isEqual(obj1, obj2)з бібліотеки underscore.js.

Ось приклад:

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

Дивіться офіційну документацію звідси: http://underscorejs.org/#isEqual

Якщо припустити, що порядок властивостей в об’єкті не змінений.

JSON.stringify () працює для глибоких і неглибоких обох типів об'єктів, не дуже впевнених у аспектах продуктивності:

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

Просте рішення цього питання, яке багато хто не розуміє, - це сортування рядків JSON (за символом). Зазвичай це швидше, ніж інші рішення, згадані тут:

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

Ще одна корисна річ щодо цього методу - ви можете фільтрувати порівняння, передаючи функцію "замінювача" до функцій JSON.stringify ( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON / stringify # Example_of_using_replacer_parameter ). Нижче наведено лише порівняння всіх клавіш об'єктів, названих "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;
});

Просто хотів зробити свій варіант порівняння об'єктів, використовуючи деякі функції es6. Він не враховує замовлення. Після перетворення всіх if / else в термінал я прийшов із наступним:

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;

        }
    )
}

Потрібна більш загальна функція порівняння об'єктів, ніж була розміщена, я підготував наступне. Критика оцінена ...

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

Якщо ви порівнюєте об'єкти JSON, ви можете використовувати https://github.com/mirek/node-rus-diff

npm install rus-diff

Використання:

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

Якщо два об'єкти різні, {$rename:{...}, $unset:{...}, $set:{...}}повертається MongoDB, подібний об'єкту.

Я зіткнувся з тією ж проблемою і вирішив написати власне рішення. Але оскільки я хочу порівнювати масиви з об'єктами і навпаки, я створив загальне рішення. Я вирішив додати функції до прототипу, але можна легко переписати їх на окремі функції. Ось код:

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

Цей алгоритм розділений на дві частини; Сама функція дорівнює і функція пошуку числового індексу властивості в масиві / об'єкті. Функція знаходження потрібна лише тому, що indexof знаходить лише числа та рядки, а об'єктів немає.

Можна назвати це так:

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

Функція повертає true або false, в даному випадку true. Алгоритм als дозволяє порівнювати дуже складні об'єкти:

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

Верхній приклад поверне істину, навіть властивості мають інший порядок. Одна невелика деталь, на яку слід звернути увагу: Цей код також перевіряє наявність одного і того ж типу двох змінних, тому "3" не є таким же, як 3.

Я бачу відповіді коду спагетті. Не використовуючи жодних сторонніх вугрів, це дуже легко.

По-перше, відсортуйте два об’єкти, ввівши їх ключові назви.

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)

Тоді просто використовуйте рядок для їх порівняння.

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

Я б радив проти хешування або серіалізації (як пропонує рішення JSON). Якщо вам потрібно перевірити, чи два об'єкти рівні, то вам потрібно визначити, що означає рівність. Можливо, всі члени даних в обох об'єктах збігаються, або може бути, що місця розташування пам'яті повинні збігатися (тобто обидві змінні посилаються на один і той же об’єкт у пам'яті), або може бути відповідати лише один член даних у кожному об'єкті.

Нещодавно я розробив об’єкт, конструктор якого створює новий ідентифікатор (починаючи з 1 і збільшуючи до 1) щоразу, коли створюється екземпляр. Цей об’єкт має функцію isEqual, яка порівнює це значення id зі значенням id іншого об'єкта та повертає істинне, якщо вони відповідають.

У цьому випадку я визначив "рівний", що означає значення значень id. Зважаючи на те, що кожен екземпляр має унікальний ідентифікатор, це може бути використане для втілення думки про те, що відповідні об'єкти також займають одне і те ж місце в пам'яті. Хоча це не обов’язково.

Корисно вважати два об'єкти рівними, якщо вони мають однакові значення для всіх властивостей і рекурсивно для всіх вкладених об'єктів і масивів. Я також вважаю такими два об'єкти рівними:

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

Аналогічно, масиви можуть мати "відсутні" елементи та невизначені елементи. Я б так само ставився до тих:

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

Функція, яка реалізує це визначення рівності:

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

Вихідний код (включаючи допоміжні функції, GeneralType та uniqueArray): Тест модуля та тест- рунер тут .

Я роблю такі припущення з цією функцією:

1. Ви керуєте об'єктами, які ви порівнюєте, і у вас є лише примітивні значення (тобто не вкладені об'єкти, функції тощо).
2. У вашому браузері є підтримка Object.keys .

Це слід трактувати як демонстрацію простої стратегії.

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

Це доповнення до всього вищезазначеного, а не заміна. Якщо вам потрібно швидко порівняти об’єкти без необхідності перевіряти зайві рекурсивні випадки. Ось знімок.

Це порівнюється з: 1) рівність кількості власних властивостей, 2) рівність імен ключових, 3) якщо bCompareValues ​​== true, рівність відповідних значень властивостей та їх типів (потрійна рівність)

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

Для порівняння ключів для простих екземплярів об'єктів пар ключ / значення я використовую:

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

Після порівняння ключів достатньо простого додаткового for..inциклу.

Складність O (N * N), N - кількість клавіш.

Я сподіваюсь / здогадуюсь, я визначаю, що об'єкти не матимуть більше 1000 властивостей ...

Я знаю, що це трохи старе, але я хотів би додати рішення, яке я придумав для цієї проблеми. У мене був об’єкт, і я хотів дізнатися, коли його дані змінилися. "щось подібне до Object.observe", і що я зробив:

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

Це можна дублювати і створювати інший набір масивів для порівняння значень і ключів. Це дуже просто, оскільки вони тепер є масивами і повертатимуться помилковими, якщо об'єкти мають різний розмір.