来源

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

这里有一个使用JavaScript新过滤功能的解决方案，非常简单。假设你有一个这样的数组。

var duplicatesArray = ['AKASH','AKASH','NAVIN','HARISH','NAVIN','HARISH','AKASH','MANJULIKA','AKASH','TAPASWENI','MANJULIKA','HARISH','TAPASWENI','AKASH','MANISH','HARISH','TAPASWENI','MANJULIKA','MANISH'];

filter函数将允许您为数组中的每个元素使用一次回调函数来创建一个新数组。所以你可以这样设置唯一的数组。

var uniqueArray = duplicatesArray.filter(function(elem, pos) {return duplicatesArray.indexOf(elem) == pos;});

在这种情况下，您的唯一数组将遍历重复数组中的所有值。elem变量表示数组中元素的值（mike、james、james和alex），位置是它在数组中的0索引位置（0,1,2,3…），duplicatesArray.indexOf（elem）值只是该元素在原始数组中第一次出现的索引。因此，因为元素'james'是重复的，所以当我们循环遍历duplicatesArray中的所有元素并将它们推送到uniqueArray时，第一次命中james时，我们的“pos”值为1，indexOf（elem）也为1，因此james被推送到unique Array。第二次命中James时，我们的“pos”值为2，indexOf（elem）仍然为1（因为它只找到数组元素的第一个实例），因此不会推送重复项。因此，uniqueArray只包含唯一值。

这是上述功能的演示。单击此处查看上述功能示例

您也可以使用地图：

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

完整样本：

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

const dedupThings = Array.from(things.thing.reduce((m, t) => m.set(t.place, t), new Map()).values());

console.log(JSON.stringify(dedupThings, null, 4));

结果：

[
    {
        "place": "here",
        "name": "stuff"
    },
    {
        "place": "there",
        "name": "morestuff"
    }
]

我认为，将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]
, [])

使用Set的一个衬垫

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”}）；//为简洁起见，将things.thing分配给myDatavar myData=things.thing；things.thing=数组.from（新集合（myData.map（JSON.stringify）））.map（JSON解析）；console.log（things.thing）

说明：

newSet（myData.map（JSON.stringify））使用字符串化的myData元素创建一个Set对象。Set对象将确保每个元素都是唯一的。然后，我使用array.from基于创建的集合的元素创建一个数组。最后，我使用JSON.parse将字符串化元素转换回对象。

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"
}]