如何为 JavaScript Set 自定义对象相等性

Question

新的 ES 6 (Harmony) 引入了新的 Set 对象。 Set 使用的身份算法类似于=== 运算符，因此不太适合比较对象：

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

如何自定义 Set 对象的相等性以便进行深度对象比较？有没有类似Javaequals(Object)的东西？

Answer 1

ES6 Set 对象没有任何比较方法或自定义比较可扩展性。

.has()、.add() 和 .delete() 方法仅适用于相同的实际对象或原语的相同值，并且无法插入或替换该逻辑。

您大概可以从 Set 派生出您自己的对象，并用首先进行深度对象比较以查找该项目是否已经在 Set 中的方法替换 .has()、.add() 和 .delete() 方法，但是性能可能不会很好，因为底层的Set 对象根本没有帮助。在调用原始 .add() 之前，您可能需要对所有现有对象进行暴力迭代，以使用您自己的自定义比较找到匹配项。

以下是来自this article and discussion 的一些关于 ES6 功能的信息：

5.2 为什么我不能配置 map 和 set 如何比较键和值？

问题：如果有办法配置什么地图就好了 键和什么集合元素被认为是相等的。为什么没有？

回答：该功能已被推迟，因为它很难 正确有效地实施。一种选择是将回调传递给 指定相等性的集合。

Java 中可用的另一个选项是通过方法指定相等性 该对象实现（Java 中的 equals()）。然而，这种方法是 可变对象的问题：一般来说，如果一个对象发生变化，它的 集合中的“位置”也必须改变。但这不是 Java中发生了什么。 JavaScript 可能会走更安全的路线 仅对特殊的不可变对象启用按值比较 （所谓的值对象）。按值比较意味着两个值 如果它们的内容相等，则认为它们相等。原始值是 在 JavaScript 中按值进行比较。

Answer 2

正如jfriend00's answer 中提到的，自定义相等关系可能不可能。

以下代码概述了计算效率高（但内存昂贵）解决方法：

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 方法返回相同的值时，两个对象才被认为是相等的。

Answer 3

正如top answer 所提到的，自定义相等对于可变对象是有问题的。好消息是（我很惊讶还没有人提到这一点）有一个非常受欢迎的库，名为 immutable-js，它提供了一组丰富的不可变类型，这些类型提供了您正在寻找的 deep value equality semantics。

这是您使用 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}]

Answer 4

为了补充这里的答案，我继续实现了一个 Map 包装器，它采用自定义散列函数、自定义相等函数，并将具有等效（自定义）散列的不同值存储在存储桶中。

可以预见的是，turned out to be slower 比 czerny's string concatenation method。

完整来源：https://github.com/makoConstruct/ValueMap

Answer 5

也许您可以尝试使用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);

Answer 6

直接比较它们似乎是不可能的，但 JSON.stringify 如果键被排序就可以工作。正如我在评论中指出的那样

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

但是我们可以使用自定义的 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

Answer 7

对于 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

Answer 8

TypedArray 作为 Set/Map 键使用的特殊但常见情况的良好字符串化方法

const key = String.fromCharCode(...new Uint16Array(myArray.buffer));

它生成最短的唯一字符串，可以很容易地转换回来。然而，这并不总是一个有效的 UTF-16 字符串，用于显示低和高代理。 Set 和 Map 似乎忽略了代理有效性。 正如在 Firefox 和 Chrome 中测量的那样，展开运算符的执行速度很慢。如果您的 myArray 具有固定大小，则在您编写时它会执行得更快：

const a = new Uint16Array(myArray.buffer);  // here: myArray = Uint32Array(2) = 8 bytes
const key = String.fromCharCode(a[0],a[1],a[2],a[3]);  // 8 bytes too

可能是这种密钥构建方法最有价值的优势：它适用于 Float32Array 和 Float64Array，没有任何舍入副作用。请注意，+0 和 -0 是不同的。无穷大是一样的。沉默的 NaN 是一样的。信号 NaN 因信号而异（在原生 JavaScript 中从未见过）。

Answer 9

致在谷歌上发现这个问题的人（就像我一样）想要使用对象作为 Key 来获取 Map 的值：

警告：此答案不适用于所有对象

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

输出：

工作