正如上面的答案所提到的，自定义相等性对于可变对象是有问题的。好消息是(我很惊讶还没有人提到这一点)有一个非常流行的库叫做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}]

正如其他人所说，目前还没有本地方法可以做到这一点。 但是如果你想用你的自定义比较器来区分一个数组，你可以尝试用reduce方法来做。

function distinct(array, equal) {
  // No need to convert it to a Set object since it may give you a wrong signal that the set can work with your objects.
  return array.reduce((p, c) => {
    p.findIndex((element) => equal(element, c)) > -1 || p.push(c);
    return p;
  }, []);
}

// You can call this method like below,
const users = distinct(
    [
      {id: 1, name: "kevin"},
      {id: 2, name: "sean"},
      {id: 1, name: "jerry"}
    ],
    (a, b) => a.id === b.id
);
...

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

JSON。stringify({a:1, b:2}) !== JSON。stringify ({2,: 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);
}

一组

现在我们使用Set。但是我们使用的是字符串集合而不是对象

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

正如其他人所说，当前版本的Set没有办法做到这一点。 我的建议是使用数组和映射的组合。

下面的代码将基于您自己定义的键创建唯一键的映射，然后将唯一项的映射转换为一个数组。

Const数组= ［ {"name": "Joe"， "age": 17}， {"name": "Bob"， "age": 17}， {"name": "Carl"， "age": 35} ］ Const key = 'age'; const arrayUniqueByKey =[…]新地图(数组。地图(项= > (项目(关键),项目))). values ()]; console.log (arrayUniqueByKey); / *输出 ［ {"name": "Bob"， "age": 17}， {"name": "Carl"， "age": 35} ］ * / //注意:这将选择列表中最后一个重复的项。

也许你可以尝试使用JSON.stringify()来进行深度对象比较。

例如:

Const arr = [ {名称:“a”,值:10}, {名称:“a”,值:20}, {名称:“a”,值:20}, {名称:“b”,价值:30}, {名称:“b”,价值:40}, {名称:“b”,价值:40} ]; const names = new Set(); Const result = arr。name .has(JSON.stringify(item)) ?names.add(JSON.stringify(item)): false); console.log(结果);

对于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中从未见过)。