Come personalizzare l'uguaglianza degli oggetti per il set JavaScript

Il nuovo ES 6 (Harmony) introduce il nuovo oggetto Set . L'algoritmo di identità utilizzato da Set è simile ===all'operatore e quindi non molto adatto per confrontare oggetti:

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

Come personalizzare l'uguaglianza per gli oggetti Set per fare un confronto profondo degli oggetti? C'è qualcosa come Java equals(Object)?

L' Setoggetto ES6 non ha alcun metodo di confronto o estensibilità di confronto personalizzata.

I .has(), .add()e .delete()metodi funzionano solo fuori essendo lo stesso oggetto reale o stesso valore per un primitivo e non hanno un mezzo a spina nella o sostituire solo quella logica.

Si potrebbe presumibilmente derivare il proprio oggetto da a Sete sostituire .has(), .add()e .delete()metodi con qualcosa che ha fatto prima un confronto approfondito di oggetti per scoprire se l'oggetto è già nel Set, ma le prestazioni probabilmente non sarebbero buone poiché l' Setoggetto sottostante non aiuterebbe affatto. Probabilmente dovresti semplicemente eseguire un'iterazione della forza bruta attraverso tutti gli oggetti esistenti per trovare una corrispondenza usando il tuo confronto personalizzato prima di chiamare l'originale .add().

Ecco alcune informazioni da questo articolo e la discussione delle funzionalità di ES6:

5.2 Perché non riesco a configurare il modo in cui mappe e set confrontano chiavi e valori?

Domanda: Sarebbe bello se ci fosse un modo per configurare quali chiavi della mappa e quali elementi del set sono considerati uguali. Perché non c'è?

Risposta: tale funzione è stata rinviata, poiché è difficile implementarla in modo corretto ed efficiente. Un'opzione è consegnare i callback alle raccolte che specificano l'uguaglianza.

Un'altra opzione, disponibile in Java, è quella di specificare l'uguaglianza tramite un metodo che l'oggetto implementa (equals () in Java). Tuttavia, questo approccio è problematico per gli oggetti mutabili: in generale, se un oggetto cambia, anche la sua "posizione" all'interno di una collezione deve cambiare. Ma non è quello che succede in Java. JavaScript probabilmente seguirà la strada più sicura abilitando il confronto solo per valore per oggetti speciali immutabili (i cosiddetti oggetti valore). Il confronto per valore significa che due valori sono considerati uguali se il loro contenuto è uguale. I valori primitivi vengono confrontati per valore in JavaScript.

Come menzionato nella risposta di jfriend00, la personalizzazione della relazione di uguaglianza probabilmente non è possibile .

Il codice seguente presenta uno schema di soluzione alternativa computazionalmente efficiente (ma memoria costosa) :

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

    // ...
}

Ogni elemento inserito deve essere implementato toIdString() metodo che restituisce stringa. Due oggetti sono considerati uguali se e solo se i loro toIdStringmetodi restituiscono lo stesso valore.

Come menziona la risposta principale , la personalizzazione dell'uguaglianza è problematica per gli oggetti mutabili. La buona notizia è (e sono sorpreso che nessuno l'abbia ancora menzionato) c'è una libreria molto popolare chiamata immutable-js che fornisce un ricco set di tipi immutabili che forniscono la semantica di uguaglianza di valore profondo che stai cercando.

Ecco il tuo esempio 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}]

Per aggiungere qui le risposte, sono andato avanti e ho implementato un wrapper Mappa che accetta una funzione hash personalizzata, una funzione di uguaglianza personalizzata e memorizza valori distinti che hanno hash equivalenti (personalizzati) nei bucket.

Com'era prevedibile, si rivelò più lento del metodo di concatenazione delle stringhe di czerny .

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

Il confronto diretto non sembra possibile, ma JSON.stringify funziona se le chiavi sono state ordinate. Come ho sottolineato in un commento

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

Ma possiamo aggirare questo con un metodo stringify personalizzato. Per prima cosa scriviamo il metodo

Stringify personalizzato

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

Il set

Ora usiamo un set. Ma usiamo un set di stringhe invece di oggetti

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

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

Ottieni tutti i valori

Dopo aver creato il set e aggiunto i valori, possiamo ottenere tutti i valori

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

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

Ecco un link con tutto in un unico file http://tpcg.io/FnJg2i

Forse puoi provare a usare JSON.stringify()per fare un confronto profondo degli oggetti.

per esempio :

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

Per gli utenti di Typescript, le risposte di altri (specialmente czerny ) possono essere generalizzate in una bella classe base sicura e riutilizzabile:

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

L'implementazione di esempio è quindi semplice: basta ignorare il stringifyKeymetodo. Nel mio caso stringo alcune uriproprietà.

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

L'uso di esempio è quindi come se fosse un normale 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

Crea un nuovo set dalla combinazione di entrambi i set, quindi confronta la lunghezza.

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 è uguale a set2 = vero

set1 è uguale a set4 = false

A qualcuno che ha trovato questa domanda su Google (come me) che desidera ottenere un valore di una mappa utilizzando un oggetto come chiave:

Attenzione: questa risposta non funzionerà con tutti gli oggetti

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

Produzione:

Lavorato