这是我的两分钱。如果您知道财产的顺序相同，则可以将元素串接起来，并从数组中删除重复项，然后再次解析数组。类似于：

var things=新对象（）；things.thing=新数组（）；thing.thing.push（{place:“here”，name:“stuff”}）；things.thing.push（{place:“there”，name:“morestuff”}）；things.thing.push（{place:“there”，name:“morestuff”}）；let-stringified=things.thing.map（i=>JSON.sringify（i））；let unique=stringified.filter（（k，idx）=>stringified.indexOf（k）==idx）.map（j=>JSON.parse（j））console.log（唯一）；

这里有另一种技术，可以找到重复的数量，并轻松地从数据对象中删除它。“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++;
            }
        }

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

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

来源

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

继续探索ES6从对象数组中删除重复项的方法：将array.prototype.filter的thisArg参数设置为new Set提供了一个不错的选择：

常量=[{地点：“这里”，名称：“东西”}，{地点：“there”，名称：“morestuff”}，{地点：“there”，名称：“morestuff”}];constfiltered=things.filter（函数（｛place，name｝）{const key=“$｛place｝$｛name｝”；回来this.has（key）&&this.add（key）；}，新设置）；console.log（已过滤）；

但是，它不能与箭头函数（）=>一起工作，因为这与它们的词法范围有关。

另一种方法是使用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（）。