我认为，将reduce与JSON.stringify结合起来以完美地比较对象，并选择性地添加那些尚未在累加器中的对象是一种优雅的方式。

请记住，在极端情况下，JSON.stringify可能会成为一个性能问题，因为阵列有许多对象，而且它们很复杂，但在大多数情况下，这是IMHO的最短路径。

var集合＝〔｛a:1｝，｛a:2｝，{a:1}，｛a：3｝〕var filtered=collection.reduce（（已过滤，项）=>{if（！filtered.some（filteredItem=>JSON.stringify（filtered item）==JSON.sstringify（item）））已过滤推送（项）返回已过滤}, [])console.log（已过滤）

另一种写法相同（但效率较低）：

collection.reduce((filtered, item) => 
  filtered.some(filteredItem => 
    JSON.stringify(filteredItem ) == JSON.stringify(item)) 
      ? filtered
      : [...filtered, item]
, [])

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

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

如果您可以使用诸如下划线或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。

可以将Object.values（）与Array.prototype.reduce（）结合使用：

const things=新对象（）；things.thing=新数组（）；thing.thing.push（{place:“here”，name:“stuff”}）；things.thing.push（{place:“there”，name:“morestuff”}）；things.thing.push（{place:“there”，name:“morestuff”}）；constresult=Object.values（things.thing.reduce（（a，c）=>（a[`${c.place}${c.name}`]=c，a），{}））；console.log（结果）；.作为控制台包装｛最大高度：100%！重要；顶部：0；｝

如果您不介意以后对唯一数组进行排序，这将是一个有效的解决方案：

things.thing
  .sort(((a, b) => a.place < b.place)
  .filter((current, index, array) =>
    index === 0 || current.place !== array[index - 1].place)

这样，您只需将当前元素与数组中的前一个元素进行比较。在过滤之前排序一次（O（n*log（n））比在整个数组中搜索每个数组元素的重复项（O（n²））要便宜。

这里是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' }]