这里有另一种技术，可以找到重复的数量，并轻松地从数据对象中删除它。“dupsCount”是重复文件数。首先对数据进行排序，然后删除。它将为您提供最快的重复删除。

  dataArray.sort(function (a, b) {
            var textA = a.name.toUpperCase();
            var textB = b.name.toUpperCase();
            return (textA < textB) ? -1 : (textA > textB) ? 1 : 0;
        });
        for (var i = 0; i < dataArray.length - 1; ) {
            if (dataArray[i].name == dataArray[i + 1].name) {
                dupsCount++;
                dataArray.splice(i, 1);
            } else {
                i++;
            }
        }

让myData=[{place:“here”，name:“stuff”}，{地点：“there”，名称：“morestuff”}，{地点：“there”，名称：“morestuff”}]；let q=[…new Map（myData.Map（obj=>[JSON.stringify（obj），obj]）.values（）]；控制台日志（q）

一个使用ES6和new Map（）的命令行。

// assign things.thing to myData
let myData = things.thing;

[...new Map(myData.map(obj => [JSON.stringify(obj), obj])).values()];

详细信息：-

对数据列表执行.map（）并将每个单独的对象转换为[key，value]对数组（长度=2），第一个元素（key）将是对象的字符串化版本，第二个元素（value）将是一个对象本身。将上述创建的数组列表添加到新的Map（）中会将键作为字符串化对象，任何相同的键添加都会导致覆盖现有的键。使用.values（）将为MapIterator提供Map中的所有值（在本例中为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"
}]

来点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的解决方案，您只想保留最后一项。该解决方案功能强大，符合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' }]

另一种方法是使用reduce函数，并使用一个新数组作为累加器。如果累加器数组中已经有一个同名的对象，那么不要将其添加到那里。

let list = things.thing;
list = list.reduce((accumulator, thing) => {
    if (!accumulator.filter((duplicate) => thing.name === duplicate.name)[0]) {
        accumulator.push(thing);
    }
    return accumulator;
}, []);
thing.things = list;

我添加了这个答案，因为我找不到与InternetExplorer11兼容的好的、可读的es6解决方案（我使用babel来处理箭头函数）。问题是IE11没有没有polyfill的Map.values（）或Set.values）。出于同样的原因，我使用filter（）[0]来获取第一个元素，而不是find（）。