如果您正在使用Lodash库，也可以使用以下函数。它应该删除重复的对象。

var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
_.uniqWith(objects, _.isEqual);

来点es6魔法怎么样？

obj.arr = obj.arr.filter((value, index, self) =>
  index === self.findIndex((t) => (
    t.place === value.place && t.name === value.name
  ))
)

参考URL

更通用的解决方案是：

const uniqueArray = obj.arr.filter((value, index) => {
  const _value = JSON.stringify(value);
  return index === obj.arr.findIndex(obj => {
    return JSON.stringify(obj) === _value;
  });
});

使用上述属性策略而不是JSON.stringify：

const isPropValuesEqual = (subject, target, propNames) =>
  propNames.every(propName => subject[propName] === target[propName]);

const getUniqueItemsByProperties = (items, propNames) => 
  items.filter((item, index, array) =>
    index === array.findIndex(foundItem => isPropValuesEqual(foundItem, item, propNames))
  );

如果希望propNames属性为数组或值，可以添加包装器：

const getUniqueItemsByProperties = (items, propNames) => {
  const propNamesArray = Array.from(propNames);

  return items.filter((item, index, array) =>
    index === array.findIndex(foundItem => isPropValuesEqual(foundItem, item, propNamesArray))
  );
};

允许getUniqueItemsByProperty（'a'）和getUniqueItemsByProperty（['a']）；

Stackblitz示例

解释

首先了解使用的两种方法：过滤器，findIndex接下来，让你的想法让你的两个对象相等，并记住这一点。如果某个东西满足我们刚刚想到的标准，我们可以将其检测为复制品，但它的位置不在具有该标准的对象的第一个实例处。因此，我们可以使用上述标准来确定某个东西是否是重复的。

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

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

这里是ES6的解决方案，您只想保留最后一项。该解决方案功能强大，符合Airbnb风格。

const things = {
  thing: [
    { place: 'here', name: 'stuff' },
    { place: 'there', name: 'morestuff1' },
    { place: 'there', name: 'morestuff2' }, 
  ],
};

const removeDuplicates = (array, key) => {
  return array.reduce((arr, item) => {
    const removed = arr.filter(i => i[key] !== item[key]);
    return [...removed, item];
  }, []);
};

console.log(removeDuplicates(things.thing, 'place'));
// > [{ place: 'here', name: 'stuff' }, { place: 'there', name: 'morestuff2' }]

这里有一个使用JavaScript新过滤功能的解决方案，非常简单。假设你有一个这样的数组。

var duplicatesArray = ['AKASH','AKASH','NAVIN','HARISH','NAVIN','HARISH','AKASH','MANJULIKA','AKASH','TAPASWENI','MANJULIKA','HARISH','TAPASWENI','AKASH','MANISH','HARISH','TAPASWENI','MANJULIKA','MANISH'];

filter函数将允许您为数组中的每个元素使用一次回调函数来创建一个新数组。所以你可以这样设置唯一的数组。

var uniqueArray = duplicatesArray.filter(function(elem, pos) {return duplicatesArray.indexOf(elem) == pos;});

在这种情况下，您的唯一数组将遍历重复数组中的所有值。elem变量表示数组中元素的值（mike、james、james和alex），位置是它在数组中的0索引位置（0,1,2,3…），duplicatesArray.indexOf（elem）值只是该元素在原始数组中第一次出现的索引。因此，因为元素'james'是重复的，所以当我们循环遍历duplicatesArray中的所有元素并将它们推送到uniqueArray时，第一次命中james时，我们的“pos”值为1，indexOf（elem）也为1，因此james被推送到unique Array。第二次命中James时，我们的“pos”值为2，indexOf（elem）仍然为1（因为它只找到数组元素的第一个实例），因此不会推送重复项。因此，uniqueArray只包含唯一值。

这是上述功能的演示。单击此处查看上述功能示例

Dang，孩子们，让我们把这件事搞砸，为什么不呢？

让uniqIds＝｛｝，source＝〔｛id:‘a’｝，｛id:'b‘｝，{id:'c‘｝、｛id:s'b‘}，｛id：‘a‘｝；let filtered=source.filter（obj=>！uniqIds[obj.id]&&（uniqIds[obj.id]=true））；console.log（已过滤）；//预期：[｛id:'a'｝，｛id:'b'｝；