要从对象数组中删除所有重复项，最简单的方法是使用过滤器：

var uniq＝{}；var arr=[｛“id”：“1”｝，｛“id”：“2”｝；var arrFiltered=arr.filter（obj=>！uniq[obj.id]&&（uniq[obj.id]=true））；console.log（'arrFiltered'，arrFiltered）；

如果需要基于对象中的多个财产的唯一数组，可以通过映射和组合对象的财产来实现。

    var hash = array.map(function(element){
        var string = ''
        for (var key in element){
            string += element[key]
        }
        return string
    })
    array = array.filter(function(element, index){
        var string = ''
        for (var key in element){
            string += element[key]
        }
        return hash.indexOf(string) == index
    })

如果您可以等到所有添加之后再消除重复项，典型的方法是首先对数组进行排序，然后消除重复项。排序避免了在遍历每个元素时扫描数组的N*N方法。

“消除重复项”函数通常称为unique或uniq。一些现有的实现可以结合这两个步骤，例如原型的uniq

如果你的图书馆还没有，这篇文章没有什么想法可以尝试（还有一些需要避免：-）！我个人认为这是最直接的：

    function unique(a){
        a.sort();
        for(var i = 1; i < a.length; ){
            if(a[i-1] == a[i]){
                a.splice(i, 1);
            } else {
                i++;
            }
        }
        return a;
    }  

    // Provide your own comparison
    function unique(a, compareFunc){
        a.sort( compareFunc );
        for(var i = 1; i < a.length; ){
            if( compareFunc(a[i-1], a[i]) === 0){
                a.splice(i, 1);
            } else {
                i++;
            }
        }
        return a;
    }

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"
}]

您也可以使用地图：

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

完整样本：

const things = new Object();

things.thing = new Array();

things.thing.push({place:"here",name:"stuff"});
things.thing.push({place:"there",name:"morestuff"});
things.thing.push({place:"there",name:"morestuff"});

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

console.log(JSON.stringify(dedupThings, null, 4));

结果：

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