str =[
{"item_id":1},
{"item_id":2},
{"item_id":2}
]

obj =[]
for (x in str){
    if(check(str[x].item_id)){
        obj.push(str[x])
    }   
}
function check(id){
    flag=0
    for (y in obj){
        if(obj[y].item_id === id){
            flag =1
        }
    }
    if(flag ==0) return true
    else return false

}
console.log(obj)

str是一个对象数组。存在具有相同值的对象（这里是一个小示例，有两个对象的item_id与2相同）。check（id）是一个函数，用于检查是否存在任何具有相同itemid的对象。如果存在，则返回false，否则返回true。根据该结果，将对象推入新的数组obj上述代码的输出为[｛“item_id”：1｝，｛“item_id”:2｝]

来点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接下来，让你的想法让你的两个对象相等，并记住这一点。如果某个东西满足我们刚刚想到的标准，我们可以将其检测为复制品，但它的位置不在具有该标准的对象的第一个实例处。因此，我们可以使用上述标准来确定某个东西是否是重复的。

向列表中再添加一个。将ES6和Array.reduce与Array.find一起使用。在此示例中，根据guid属性筛选对象。

let filtered = array.reduce((accumulator, current) => {
  if (! accumulator.find(({guid}) => guid === current.guid)) {
    accumulator.push(current);
  }
  return accumulator;
}, []);

扩展此选项以允许选择属性并将其压缩为一行：

const uniqify = (array, key) => array.reduce((prev, curr) => prev.find(a => a[key] === curr[key]) ? prev : prev.push(curr) && prev, []);

要使用它，请将对象数组和要进行重复数据消除的键的名称作为字符串值传递：

const result = uniqify(myArrayOfObjects, 'guid')

这里有一个使用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只包含唯一值。

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

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实例。

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

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