Как настроить равенство объектов для 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 ]

Как настроить равенство для объектов Set для глубокого сравнения объектов? Есть что-нибудь похожее на Java equals(Object)?

Объект ES6 Setне имеет методов сравнения или настраиваемой расширяемости сравнения.

В .has(), .add()и .delete()методы работы только от него быть таким же реальным объектом или же значением для примитивного и не имеют средств для подключения к или заменить только что логика.

Вы могли бы предположительно получить свой собственный объект из a Setи replace .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методы возвращают одно и то же значение.

Как отмечается в верхнем ответе , настройка равенства проблематична для изменчивых объектов. Хорошая новость (и я удивлен, что никто еще не упомянул об этом) есть очень популярная библиотека под названием immutable-js, которая предоставляет богатый набор неизменяемых типов, которые обеспечивают семантику глубокого равенства равенства, которую вы ищете.

Вот ваш пример использования immutable-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. Сначала мы пишем метод

Custom 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 = true

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

Вывод:

Работал