JavaScriptセットのオブジェクト等価性をカスタマイズする方法

新しいES 6（ハーモニー）は新しい Setオブジェクトがます。Setで使用されるIDアルゴリズムは===演算子に似ているため、オブジェクトの比較にはあまり適していません。

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オブジェクトには、compareメソッドやカスタム比較拡張機能はありません。

.has()、.add()および.delete()方法は、プリミティブのために同じ実際のオブジェクトまたは同じ値であるだけでオフに動作し、ちょうどそのロジックを差し込むまたは交換する手段を持っていません。

おそらく、から独自のオブジェクトを派生させ、とメソッドを最初にディープオブジェクト比較を行ってアイテムがセット内にあるかどうかを確認する何かでメソッドをSet置き換えることができますが、基礎となるオブジェクトが役に立たないため、パフォーマンスはおそらく良くありませんまったく。オリジナルを呼び出す前に、独自のカスタム比較を使用して一致を見つけるために、既存のすべてのオブジェクトに対してブルートフォースの反復を実行する必要があるでしょう.has().add().delete()Set.add()。

この記事の情報とES6機能の説明を以下に示します。

5.2マップとセットがキーと値を比較する方法を設定できないのはなぜですか？

質問：どのマップキーとどのセット要素が等しいと見なされるかを構成する方法があればいいでしょう。なぜそこにないのですか？

回答：この機能は、適切かつ効率的に実装することが難しいため、延期されました。1つのオプションは、同等性を指定するコレクションにコールバックを渡すことです。

Javaで利用可能なもう1つのオプションは、オブジェクトが実装するメソッド（Javaの場合はequals（））を使用して等価性を指定することです。ただし、このアプローチは変更可能なオブジェクトには問題があります。一般に、オブジェクトが変更されると、コレクション内の「場所」も変更される必要があります。しかし、それはJavaでは起こりません。JavaScriptはおそらく、特別な不変オブジェクト（いわゆる値オブジェクト）の値による比較のみを有効にするというより安全な方法になります。値による比較とは、2つの値の内容が等しい場合、それらは等しいと見なされることを意味します。プリミティブ値は、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()文字列を返すメソッドを実装する必要があります。2つのオブジェクトが等しいと見なされるのは、それらの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}）;

しかし、カスタムの文字列化メソッドでそれを回避することができます。最初にメソッドを書きます

カスタム文字列化

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

これはすべてが1つのファイルにあるリンクです 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");

出力：

働いた