Como personalizar a igualdade de objetos para o conjunto JavaScript

O novo ES 6 (Harmony) apresenta o novo objeto Set . O algoritmo de identidade usado pelo Set é semelhante ao ===operador e, portanto, não é muito adequado para comparar objetos:

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

Como personalizar a igualdade dos objetos Set para fazer uma comparação profunda dos objetos? Existe algo como Java equals(Object)?

O Setobjeto ES6 não possui nenhum método de comparação ou extensibilidade de comparação personalizada.

Os métodos .has(), .add()e .delete()funcionam apenas com o mesmo objeto real ou o mesmo valor de uma primitiva e não têm como conectar ou substituir apenas essa lógica.

Presumivelmente, você poderia derivar seu próprio objeto de Setae replace .has(), .add()e .delete()métodos por algo que fez uma comparação profunda de objetos primeiro para descobrir se o item já está no Conjunto, mas o desempenho provavelmente não seria bom, pois o Setobjeto subjacente não ajudaria em absoluto. Você provavelmente precisaria fazer uma iteração de força bruta em todos os objetos existentes para encontrar uma correspondência usando sua própria comparação personalizada antes de chamar o original .add().

Aqui estão algumas informações deste artigo e discussão dos recursos do ES6:

5.2 Por que não consigo configurar como mapas e conjuntos comparam chaves e valores?

Pergunta: Seria bom se houvesse uma maneira de configurar quais chaves de mapa e quais elementos de conjunto são considerados iguais. Por que não existe?

Resposta: Esse recurso foi adiado, pois é difícil de implementar de maneira adequada e eficiente. Uma opção é entregar retornos de chamada para coleções que especificam igualdade.

Outra opção, disponível em Java, é especificar a igualdade por meio de um método que o objeto implementa (equals () em Java). No entanto, essa abordagem é problemática para objetos mutáveis: em geral, se um objeto é alterado, sua “localização” dentro de uma coleção também precisa ser alterada. Mas não é isso que acontece em Java. O JavaScript provavelmente seguirá a rota mais segura, permitindo apenas a comparação por valor de objetos imutáveis ​​especiais (os chamados objetos de valor). Comparação por valor significa que dois valores são considerados iguais se seu conteúdo for igual. Valores primitivos são comparados por valor em JavaScript.

Como mencionado na resposta de jfriend00, a personalização da relação de igualdade provavelmente não é possível .

O código a seguir apresenta um esboço da solução alternativa computacionalmente eficiente (mas com memória dispendiosa) :

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

    // ...
}

Cada elemento inserido deve implementar o toIdString()método que retorna string. Dois objetos são considerados iguais se e somente se seus toIdStringmétodos retornarem o mesmo valor.

Como a resposta principal menciona, personalizar a igualdade é problemático para objetos mutáveis. A boa notícia é (e estou surpreso que ninguém tenha mencionado isso ainda) que existe uma biblioteca muito popular chamada immutable-js que fornece um rico conjunto de tipos imutáveis ​​que fornecem a profunda semântica de igualdade de valor que você está procurando.

Aqui está o seu exemplo usando 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}]

Para adicionar as respostas aqui, fui adiante e implementei um invólucro de mapa que usa uma função de hash personalizada, uma função de igualdade personalizada e armazena valores distintos que possuem hashes (personalizados) equivalentes em buckets.

Previsivelmente, acabou sendo mais lento que o método de concatenação de strings do czerny .

Fonte completa aqui: https://github.com/makoConstruct/ValueMap

Compará-los diretamente parece não ser possível, mas o JSON.stringify funciona se as chaves foram classificadas. Como apontei em um comentário

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

Mas podemos contornar isso com um método stringify personalizado. Primeiro, escrevemos o método

Stringify personalizado

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

O conjunto

Agora usamos um conjunto. Mas usamos um conjunto de seqüências de caracteres em vez de objetos

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

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

Obter todos os valores

Depois de criarmos o conjunto e adicionarmos os valores, podemos obter todos os valores por

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

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

Aqui está um link com tudo em um arquivo http://tpcg.io/FnJg2i

Talvez você possa tentar usar JSON.stringify() para fazer uma comparação profunda de objetos.

por exemplo :

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

Para usuários do Typecript, as respostas de outras pessoas (especialmente do czerny ) podem ser generalizadas para uma boa classe base segura e reutilizável:

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

A implementação de exemplo é assim simples: basta substituir o stringifyKeymétodo. No meu caso, eu especifico alguma uripropriedade.

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

O uso de exemplo é como se isso fosse regular 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

Crie um novo conjunto a partir da combinação dos dois conjuntos e compare o comprimento.

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 é igual a set2 = true

set1 é igual a set4 = false

Para alguém que encontrou essa pergunta no Google (como eu) que deseja obter o valor de um mapa usando um objeto como Chave:

Atenção: esta resposta não funcionará com todos os objetos

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

Resultado:

Trabalhou