简单高效的解决方案，运行时间比现有的70多个答案更好：

const ids = array.map(o => o.id)
const filtered = array.filter(({id}, index) => !ids.includes(id, index + 1))

例子：

const arr=[｛id:1，名称：“one”｝，｛id:2，名称：‘two’｝，{id:1，姓名：‘one’｝]常量id=arr.map（o=>o.id）constfiltered=arr.filter（（｛id｝，索引）=>！ids.includes（id，索引+1））console.log（已过滤）

工作原理：

Array.filter（）通过检查先前映射的id数组是否包含当前id来删除所有重复的对象（｛id｝仅将对象销毁为其id）。为了只过滤出实际的重复项，它使用了Array.includes（）的第二个参数fromIndex，索引为+1，这将忽略当前对象和所有先前对象。

由于过滤器回调方法的每一次迭代都将只搜索从当前索引+1开始的数组，这也大大减少了运行时间，因为只有以前未过滤的对象才会被检查。

这显然也适用于任何其他不称为id的键、多个键甚至所有键。

如果您只需要通过对象的一个字段进行比较，则可以使用Array迭代方法执行此操作：

    function uniq(a, param){
        return a.filter(function(item, pos, array){
            return array.map(function(mapItem){ return mapItem[param]; }).indexOf(item[param]) === pos;
        })
    }

    uniq(things.thing, 'place');

这里有另一种技术，可以找到重复的数量，并轻松地从数据对象中删除它。“dupsCount”是重复文件数。首先对数据进行排序，然后删除。它将为您提供最快的重复删除。

  dataArray.sort(function (a, b) {
            var textA = a.name.toUpperCase();
            var textB = b.name.toUpperCase();
            return (textA < textB) ? -1 : (textA > textB) ? 1 : 0;
        });
        for (var i = 0; i < dataArray.length - 1; ) {
            if (dataArray[i].name == dataArray[i + 1].name) {
                dupsCount++;
                dataArray.splice(i, 1);
            } else {
                i++;
            }
        }

removeDucplicates（）接受一个对象数组，并返回一个没有任何重复对象的新数组（基于id属性）。

const allTests = [
  {name: 'Test1', id: '1'}, 
  {name: 'Test3', id: '3'},
  {name: 'Test2', id: '2'},
  {name: 'Test2', id: '2'},
  {name: 'Test3', id: '3'}
];

function removeDuplicates(array) {
  let uniq = {};
  return array.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true))
}

removeDuplicates(allTests);

预期结果：

[
  {name: 'Test1', id: '1'}, 
  {name: 'Test3', id: '3'},
  {name: 'Test2', id: '2'}
];

首先，我们将变量uniq的值设置为空对象。

接下来，我们过滤对象数组。Filter创建一个新数组，其中包含通过所提供函数实现的测试的所有元素。

return array.filter(obj => !uniq[obj.id] && (uniq[obj.id] = true));

上面，我们使用了&&的短路功能。如果&&的左侧求值为true，则返回&&右侧的值。如果左侧为false，则返回&&左侧的内容。

对于每个对象（obj），我们检查uniq中名为obj.id值的属性（在这种情况下，在第一次迭代时，它将检查属性“1”。）我们希望它返回的结果（true或false）相反，这就是为什么我们使用！在里面uniq[obj.id]。如果uniq已经具有id属性，则返回true，其计算结果为false（！），告诉过滤函数不要添加该obj。但是，如果未找到obj.id属性，它返回false，然后计算结果为true（！）并返回&&或（uniq[obj.id]=true）右侧的所有内容。这是一个truthy值，告诉filter方法将该obj添加到返回的数组中，并且还将属性｛1:true｝添加到uniq中。这确保不会再添加具有相同id的任何其他obj实例。

const uniqueElements = (arr, fn) => arr.reduce((acc, v) => {
    if (!acc.some(x => fn(v, x))) { acc.push(v); }
    return acc;
}, []);

const stuff = [
    {place:"here",name:"stuff"},
    {place:"there",name:"morestuff"},
    {place:"there",name:"morestuff"},
];

const unique = uniqueElements(stuff, (a,b) => a.place === b.place && a.name === b.name );

//console.log( unique );

[{
    "place": "here",
    "name": "stuff"
  },
  {
    "place": "there",
    "name": "morestuff"
}]

如果您不介意以后对唯一数组进行排序，这将是一个有效的解决方案：

things.thing
  .sort(((a, b) => a.place < b.place)
  .filter((current, index, array) =>
    index === 0 || current.place !== array[index - 1].place)

这样，您只需将当前元素与数组中的前一个元素进行比较。在过滤之前排序一次（O（n*log（n））比在整个数组中搜索每个数组元素的重复项（O（n²））要便宜。