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

为懒惰的Typescript开发人员提供快速（运行时更少）和类型安全的答案：

export const uniqueBy = <T>( uniqueKey: keyof T, objects: T[]): T[] => {
  const ids = objects.map(object => object[uniqueKey]);
  return objects.filter((object, index) => !ids.includes(object[uniqueKey], index + 1));
} 

使用ES6“reduce”和“find”数组助手方法的简单解决方案

工作效率高，非常好！

"use strict";

var 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"
});

// the logic is here

function removeDup(something) {
    return something.thing.reduce(function (prev, ele) {
        var found = prev.find(function (fele) {
            return ele.place === fele.place && ele.name === fele.name;
        });
        if (!found) {
            prev.push(ele);
        }
        return prev;
    }, []);
}
console.log(removeDup(things));

这个解决方案最适合我，因为它使用了Array.from方法，而且它的长度更短，可读性更强。

let person = [
{name: "john"}, 
{name: "jane"}, 
{name: "imelda"}, 
{name: "john"},
{name: "jane"}
];

const data = Array.from(new Set(person.map(JSON.stringify))).map(JSON.parse);
console.log(data);

function dupData() {
  var arr = [{ comment: ["a", "a", "bbb", "xyz", "bbb"] }];
  let newData = [];
  comment.forEach(function (val, index) {
    if (comment.indexOf(val, index + 1) > -1) {
      if (newData.indexOf(val) === -1) { newData.push(val) }
    }
  })
}

从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（选项列表）