So passen Sie die Objektgleichheit für JavaScript Set an

Mit dem neuen ES 6 (Harmony) wird ein neues Set- Objekt eingeführt. Der von Set verwendete Identitätsalgorithmus ähnelt dem ===Operator und ist daher für den Vergleich von Objekten nicht besonders geeignet:

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

Wie kann ich die Gleichheit für Set-Objekte anpassen, um einen tiefen Objektvergleich durchzuführen? Gibt es so etwas wie Java equals(Object)?

Das ES6- SetObjekt verfügt über keine Vergleichsmethoden oder benutzerdefinierte Vergleichserweiterbarkeit.

Die .has(), .add()und .delete()Methoden funktionieren nur ab es das gleiche eigentliche Objekt oder denselben Wert für ein primitives Wesen und haben keine Mittel , um Stecker in oder ersetzen Sie einfach die Logik.

Vermutlich könnten Sie Ihr eigenes Objekt von a ableiten und Methoden Setersetzen .has(), die zuerst einen umfassenden Objektvergleich durchgeführt haben, um festzustellen, ob sich das Element bereits im Set befindet. Die Leistung wäre jedoch wahrscheinlich nicht gut, da das zugrunde liegende Objekt nicht hilfreich wäre überhaupt. Sie müssten wahrscheinlich nur eine Brute-Force-Iteration durch alle vorhandenen Objekte durchführen, um eine Übereinstimmung mit Ihrem eigenen benutzerdefinierten Vergleich zu finden, bevor Sie das Original aufrufen ..add().delete()Set.add()

Hier einige Informationen aus diesem Artikel und eine Diskussion der ES6-Funktionen:

5.2 Warum kann ich nicht konfigurieren, wie Maps und Sets Schlüssel und Werte vergleichen?

Frage: Es wäre schön, wenn es eine Möglichkeit gäbe, zu konfigurieren, welche Map-Schlüssel und welche Set-Elemente als gleich angesehen werden. Warum gibt es nicht?

Antwort: Diese Funktion wurde verschoben, da es schwierig ist, sie ordnungsgemäß und effizient zu implementieren. Eine Möglichkeit besteht darin, Rückrufe an Sammlungen zu übergeben, in denen Gleichheit angegeben ist.

Eine weitere in Java verfügbare Option besteht darin, die Gleichheit über eine Methode anzugeben, die das Objekt implementiert (equals () in Java). Dieser Ansatz ist jedoch für veränderbare Objekte problematisch: Wenn sich ein Objekt ändert, muss sich im Allgemeinen auch seine „Position“ innerhalb einer Sammlung ändern. Aber das passiert in Java nicht. JavaScript wird wahrscheinlich den sichereren Weg gehen, nur den Vergleich nach Wert für spezielle unveränderliche Objekte (sogenannte Wertobjekte) zu ermöglichen. Wertvergleich bedeutet, dass zwei Werte als gleich angesehen werden, wenn ihr Inhalt gleich ist. Primitive Werte werden in JavaScript nach Wert verglichen.

Wie in der Antwort von jfriend00 erwähnt, ist eine Anpassung der Gleichheitsbeziehung wahrscheinlich nicht möglich .

Der folgende Code enthält einen Überblick über die rechnerisch effiziente (aber speicherintensive) Problemumgehung :

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

    // ...
}

Jedes eingefügte Element muss eine toIdString()Methode implementieren , die eine Zeichenfolge zurückgibt. Zwei Objekte werden genau dann als gleich angesehen, wenn ihre toIdStringMethoden denselben Wert zurückgeben.

Wie in der Top-Antwort erwähnt, ist das Anpassen der Gleichheit für veränderbare Objekte problematisch. Die gute Nachricht ist (und ich bin überrascht, dass dies noch niemand erwähnt hat), dass es eine sehr beliebte Bibliothek namens immutable-js gibt , die eine Vielzahl unveränderlicher Typen bietet, die die von Ihnen gesuchte tiefe Gleichheitssemantik bieten.

Hier ist Ihr Beispiel mit unveränderlichen-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}]

Um die Antworten hier zu ergänzen, habe ich einen Map-Wrapper implementiert, der eine benutzerdefinierte Hash-Funktion und eine benutzerdefinierte Gleichheitsfunktion verwendet und unterschiedliche Werte mit äquivalenten (benutzerdefinierten) Hashes in Buckets speichert.

Vorhersehbar stellte sich heraus, dass es langsamer war als die String-Verkettungsmethode von czerny .

Vollständige Quelle hier: https://github.com/makoConstruct/ValueMap

Ein direkter Vergleich scheint nicht möglich zu sein, aber JSON.stringify funktioniert, wenn die Schlüssel nur sortiert wurden. Wie ich in einem Kommentar betonte

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

Aber wir können das mit einer benutzerdefinierten Stringify-Methode umgehen. Zuerst schreiben wir die Methode

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

Der Satz

Jetzt benutzen wir ein Set. Wir verwenden jedoch eine Reihe von Zeichenfolgen anstelle von Objekten

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

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

Holen Sie sich alle Werte

Nachdem wir die Menge erstellt und die Werte hinzugefügt haben, können wir alle Werte von abrufen

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

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

Hier ist ein Link mit allen in einer Datei http://tpcg.io/FnJg2i

Vielleicht können Sie versuchen, einen JSON.stringify()tiefen Objektvergleich durchzuführen.

zum Beispiel :

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

Für Typescript-Benutzer können die Antworten anderer (insbesondere von czerny ) auf eine nette typsichere und wiederverwendbare Basisklasse verallgemeinert werden:

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

Die Beispielimplementierung ist dann so einfach: Überschreiben Sie einfach die stringifyKeyMethode. In meinem Fall stringifiziere ich eine uriEigenschaft.

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

Beispielgebrauch ist dann, als ob dies ein regulärer war 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

Erstellen Sie einen neuen Satz aus der Kombination beider Sätze und vergleichen Sie dann die Länge.

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 ist gleich set2 = true

set1 ist gleich set4 = false

Für jemanden, der diese Frage bei Google gefunden hat (wie ich), der einen Wert einer Karte mit einem Objekt als Schlüssel erhalten möchte:

Warnung: Diese Antwort funktioniert nicht mit allen Objekten

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

Ausgabe:

Hat funktioniert