Як налаштувати рівність об'єктів для JavaScript Set

Новий ES 6 (Гармонія) представляє новий об'єкт Set . Алгоритм ідентичності, який використовується Set, схожий з ===оператором і не дуже підходить для порівняння об'єктів:

var set = new Set();
set.add({a:1});
set.add({a:1});
console.log([...set.values()]); // Array [ Object, Object ]

Як налаштувати рівність для заданих об'єктів, щоб зробити глибоке порівняння об'єктів? Чи є щось на кшталт Java equals(Object)?

Об'єкт ES6 Setне має жодних методів порівняння або розширення спеціальної порівняльності.

І .has(), .add()і .delete()методи працюють лише за те, що вони є тим самим фактичним об'єктом або тим самим значенням для примітиву і не мають засобів підключення або заміни саме цієї логіки.

Ви, мабуть, можете отримати власний об'єкт від a Setі замінити .has(), .add()а також .delete()методами з чимось, що спершу зробив глибоке порівняння об'єкта, щоб виявити, чи є елемент вже в Наборі, але ефективність, ймовірно, не буде хорошою, оскільки базовий Setоб'єкт не допоможе зовсім. Вам, мабуть, доведеться просто зробити грубу силу ітерації через усі існуючі об'єкти, щоб знайти збіг за допомогою власного користувацького порівняння перед тим, як викликати оригінал.add() .

Ось деяка інформація з цієї статті та обговорення особливостей ES6:

5.2 Чому я не можу налаштувати, як карти та набори порівнюють ключі та значення?

Питання: Було б непогано, якби був спосіб налаштувати, які клавіші карти та які елементи набору вважаються рівними. Чому його немає?

Відповідь: Ця функція була відкладена, оскільки її важко правильно та ефективно реалізувати. Один із варіантів - передавати зворотні дзвінки колекціям, що визначають рівність.

Інший варіант, доступний на Java, - це визначити рівність методом, який об'єкт реалізує (equals () у Java). Однак такий підхід є проблематичним для змінних об'єктів: загалом, якщо об'єкт змінюється, його "розташування" всередині колекції також має змінюватися. Але це не те, що відбувається в Java. JavaScript, ймовірно, піде більш безпечним шляхом, лише дозволяючи порівнювати значення за спеціальними незмінними об'єктами (так звані об'єкти значення). Порівняння за значенням означає, що два значення вважаються рівними, якщо їх зміст є рівним. Примітивні значення порівнюються за значенням у JavaScript.

Як зазначено у відповіді jfriend00, налаштування відношення рівності, ймовірно, неможливо .

Наступний код представляє контур обчислювально ефективного (але пам'яті дорогого) рішення :

class GeneralSet {

    constructor() {
        this.map = new Map();
        this[Symbol.iterator] = this.values;
    }

    add(item) {
        this.map.set(item.toIdString(), item);
    }

    values() {
        return this.map.values();
    }

    delete(item) {
        return this.map.delete(item.toIdString());
    }

    // ...
}

Кожен вставлений елемент повинен реалізувати toIdString()метод, який повертає рядок. Два об'єкти вважаються рівними тоді і тільки тоді, коли їхні toIdStringметоди повертають однакове значення.

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

Ось ваш приклад використання незмінного js :

const { Map, Set } = require('immutable');
var set = new Set();
set = set.add(Map({a:1}));
set = set.add(Map({a:1}));
console.log([...set.values()]); // [Map {"a" => 1}]

Щоб додати відповіді тут, я продовжив і застосував обгортку Map, яка виконує власну хеш-функцію, спеціальну функцію рівності та зберігає у відрах різні значення, які мають еквівалентні (спеціальні) хеші.

Передбачувано він виявився повільніше, ніж метод струнної конкатенації czerny .

Повне джерело тут: https://github.com/makoConstruct/ValueMap

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

JSON.stringify ({a: 1, b: 2})! == JSON.stringify ({b: 2, a: 1});

Але ми можемо обійти це за допомогою спеціального методу stringify. Спочатку пишемо метод

Спеціальна строкованість

Object.prototype.stringifySorted = function(){
    let oldObj = this;
    let obj = (oldObj.length || oldObj.length === 0) ? [] : {};
    for (let key of Object.keys(this).sort((a, b) => a.localeCompare(b))) {
        let type = typeof (oldObj[key])
        if (type === 'object') {
            obj[key] = oldObj[key].stringifySorted();
        } else {
            obj[key] = oldObj[key];
        }
    }
    return JSON.stringify(obj);
}

Набір

Тепер ми використовуємо набір. Але ми використовуємо набір рядків замість об'єктів

let set = new Set()
set.add({a:1, b:2}.stringifySorted());

set.has({b:2, a:1}.stringifySorted());
// returns true

Отримайте всі значення

Після того, як ми створили набір і додали значення, ми можемо отримати всі значення за

let iterator = set.values();
let done = false;
while (!done) {
  let val = iterator.next();

  if (!done) {
    console.log(val.value);
  }
  done = val.done;
}

Ось посилання з усіма в одному файлі http://tpcg.io/FnJg2i

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

наприклад :

const arr = [
  {name:'a', value:10},
  {name:'a', value:20},
  {name:'a', value:20},
  {name:'b', value:30},
  {name:'b', value:40},
  {name:'b', value:40}
];

const names = new Set();
const result = arr.filter(item => !names.has(JSON.stringify(item)) ? names.add(JSON.stringify(item)) : false);

console.log(result);

Для користувачів Typescript відповіді інших (особливо czerny ) можуть бути узагальнені до хорошого базового класу, безпечного для використання та багаторазового використання:

/**
 * Map that stringifies the key objects in order to leverage
 * the javascript native Map and preserve key uniqueness.
 */
abstract class StringifyingMap<K, V> {
    private map = new Map<string, V>();
    private keyMap = new Map<string, K>();

    has(key: K): boolean {
        let keyString = this.stringifyKey(key);
        return this.map.has(keyString);
    }
    get(key: K): V {
        let keyString = this.stringifyKey(key);
        return this.map.get(keyString);
    }
    set(key: K, value: V): StringifyingMap<K, V> {
        let keyString = this.stringifyKey(key);
        this.map.set(keyString, value);
        this.keyMap.set(keyString, key);
        return this;
    }

    /**
     * Puts new key/value if key is absent.
     * @param key key
     * @param defaultValue default value factory
     */
    putIfAbsent(key: K, defaultValue: () => V): boolean {
        if (!this.has(key)) {
            let value = defaultValue();
            this.set(key, value);
            return true;
        }
        return false;
    }

    keys(): IterableIterator<K> {
        return this.keyMap.values();
    }

    keyList(): K[] {
        return [...this.keys()];
    }

    delete(key: K): boolean {
        let keyString = this.stringifyKey(key);
        let flag = this.map.delete(keyString);
        this.keyMap.delete(keyString);
        return flag;
    }

    clear(): void {
        this.map.clear();
        this.keyMap.clear();
    }

    size(): number {
        return this.map.size;
    }

    /**
     * Turns the `key` object to a primitive `string` for the underlying `Map`
     * @param key key to be stringified
     */
    protected abstract stringifyKey(key: K): string;
}

Приклад реалізації тоді такий простий: просто перекрийте stringifyKeyметод. У моєму випадку я впорядкую деяку uriвластивість.

class MyMap extends StringifyingMap<MyKey, MyValue> {
    protected stringifyKey(key: MyKey): string {
        return key.uri.toString();
    }
}

Приклад використання - це так, ніби це було звичайним Map<K, V>.

const key1 = new MyKey(1);
const value1 = new MyValue(1);
const value2 = new MyValue(2);

const myMap = new MyMap();
myMap.set(key1, value1);
myMap.set(key1, value2); // native Map would put another key/value pair

myMap.size(); // returns 1, not 2

Створіть новий набір із комбінації обох наборів, а потім порівняйте довжину.

let set1 = new Set([1, 2, 'a', 'b'])
let set2 = new Set([1, 'a', 'a', 2, 'b'])
let set4 = new Set([1, 2, 'a'])

function areSetsEqual(set1, set2) {
  const set3 = new Set([...set1], [...set2])
  return set3.size === set1.size && set3.size === set2.size
}

console.log('set1 equals set2 =', areSetsEqual(set1, set2))
console.log('set1 equals set4 =', areSetsEqual(set1, set4))

set1 дорівнює set2 = вірно

set1 дорівнює set4 = false

Користувачеві, який знайшов це запитання в Google (як я), бажаючи отримати значення Карти за допомогою об’єкта як ключа:

Увага: ця відповідь працюватиме не з усіма об'єктами

var map = new Map<string,string>();

map.set(JSON.stringify({"A":2} /*string of object as key*/), "Worked");

console.log(map.get(JSON.stringify({"A":2}))||"Not worked");

Вихід:

Працювали