这是一种通用的方法：传入一个函数，该函数测试数组的两个元素是否相等。在本例中，它比较所比较的两个对象的名称和位置财产的值。

ES5答案

函数removeDucplicates（arr，equals）{var originalArr=arr.slice（0）；变量i，len，val；arr.length=0；对于（i=0，len=原始Arr.length；i<len；++i）{val=原始Arr[i]；if（！arr.some（函数（项）｛return equals（项，val）；｝））{arr.push（val）；}}}函数thingsEqual（thing1，thing2）{返回thing1.place==thing2.place&&thing.name===thing.name；}var事物=[{地点：“这里”，名称：“东西”}，{地点：“there”，名称：“morestuff”}，{地点：“there”，名称：“morestuff”}];删除重复项（things，thingsEqual）；console.log（things）；

ES3原始答案

function arrayContains(arr, val, equals) {
    var i = arr.length;
    while (i--) {
        if ( equals(arr[i], val) ) {
            return true;
        }
    }
    return false;
}

function removeDuplicates(arr, equals) {
    var originalArr = arr.slice(0);
    var i, len, j, val;
    arr.length = 0;

    for (i = 0, len = originalArr.length; i < len; ++i) {
        val = originalArr[i];
        if (!arrayContains(arr, val, equals)) {
            arr.push(val);
        }
    }
}

function thingsEqual(thing1, thing2) {
    return thing1.place === thing2.place
        && thing1.name === thing2.name;
}

removeDuplicates(things.thing, thingsEqual);

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

如果您可以使用诸如下划线或lodash之类的Javascript库，我建议查看它们库中的_.uniq函数。来自lodash：

_.uniq(array, [isSorted=false], [callback=_.identity], [thisArg])

基本上，您传入数组，这里是一个对象文本，然后传入要在原始数据数组中删除重复项的属性，如下所示：

var data = [{'name': 'Amir', 'surname': 'Rahnama'}, {'name': 'Amir', 'surname': 'Stevens'}];
var non_duplidated_data = _.uniq(data, 'name'); 

更新：Lodash现在也引入了.uniqBy。

来源

JSFiddle公司

这将在不传递任何键的情况下删除重复对象。

uniqueArray=a=>[…new Set（.map（o=>JSON.stringify（o））].map（s=>JSON.parse（s））；var objects=[｛'x'：1，'y'：2｝，｛'x'：2，'y':1｝，{'x':1，'y'：2}]；var unique=uniqueArray（对象）；console.log（“原始对象”，对象）；console.log（“唯一”，唯一）；

uniqueArray = a => [...new Set(a.map(o => JSON.stringify(o)))].map(s => JSON.parse(s));

    var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];

    var unique = uniqueArray(objects);
    console.log(objects);
    console.log(unique);

从react js中的对象数组中删除重复项（工作正常）let optionList=[]；var dataArr=this.state.itemArray.map（item=>{返回[item.name，item]});var maparr=新地图（dataArr）；var结果=[…maparr.values（）]；如果（results.length>0）{results.map（数据=>{if（data.lead_owner！==null）{optionList.push（｛label:data.name，value：data.name}）；}返回true；});}console.log（选项列表）

这个呢

function dedupe(arr, compFn){
    let res = [];
    if (!compFn) compFn = (a, b) => { return a === b };
    arr.map(a => {if(!res.find(b => compFn(a, b))) res.push(a)});
    return res;
}