如何删除对象数组中的重复项？

Question

我有一个看起来像这样的数组：

var array = 
[
    {
        key : { id : 1 , pack : "pack 1"},
        values : [
            {
                item : { id : 1 , name : "item1"},
                itemP : {id : 2 , name : "itemP12"}
            },
            {
                item : { id : 4 , name : "item4"},
                itemP : {id : 2 , name : "itemP12"}
            },
        ]
    }
]

我想删除重复的 itemP，所以使用一个函数，它看起来像这样：

var array =
[
    {
        key : { id : 1 , pack : "pack 1"},
        values : [
            {
                item : { id : 1 , name : "item1"},
                itemP : {id : 2 , name : "itemP12"}
            },
            {
                item : { id : 4 , name : "item4"},
                itemP : null
            },
        ]
    }
]

当我尝试时，我总是有错误。 有可能做到这一点吗？

更新

我尝试这样做：

  console.log(array.map(pack => 
    pack.values.map((item) => {
      var test =  JSON.stringify(item)
      var set = new Set(test)

      return Array.from(set).map((item)=> JSON.parse(item))
      }
    )

  ))

JSON 输入意外结束

我也尝试过一些会过滤的东西，但它不起作用：

  console.log(this.package.map(pack => pack.values.filter(
    (value, index , array) => array.itemP.indexOf(value) === index
  )))

Answer 1

要达到预期的结果，请使用以下使用地图的选项

1. 使用地图循环数组
2. 使用 nameArr 检查重复并分配空值
3. 循环值数组并使用 indexOf 检查 nameArr 中的名称并分配 null

 var array = [ { key : { id : 1 , pack : "pack 1"}, values : [ { item : { id : 1 , name : "item1"}, itemP : {id : 2 , name : "itemP12"} }, { item : { id : 4 , name : "item4"}, itemP : {id : 2 , name : "itemP12"} } ] } ] console.log(array.map(v => { let nameArr = [] v.values = v.values.map(val => { if(nameArr.indexOf(val.itemP.name) !== -1){ val.itemP.name = null }else{ nameArr.push(val.itemP.name) } return val }) return v }))

Answer 2

您可以使用 map 和一个对象来检查它是否已经存在。 喜欢

var obj = {}

并循环值

var values = [
            {
                item : { id : 1 , name : "item1"},
                itemP : {id : 2 , name : "itemP12"}
            },
            {
                item : { id : 4 , name : "item4"},
                itemP : {id : 2 , name : "itemP12"}
            }
        ]

values.map((v) => {
    if(!obj[v.itemP.id + '-' + v.itemP.name]) { 
     obj[v.itemP.id + '-' + v.itemP.name] = true; 
     return v;
    }
    return { item : v.item }

})

Answer 3

我建议克隆整个结构并在克隆的结构中将对象值设置为 null，而不是映射每个关键属性，以避免无意中改变原始结构。

 function nullifyDupes(array) { const clone = JSON.parse(JSON.stringify(array)); const seen = {}; clone.forEach(pack => { pack.values.forEach(items => { for (const item in items) { const id = items[item].id; if (seen[id]) items[item] = null; else seen[id] = true; } }); }); return clone; } const originalArray = [{ key : { id : 1 , pack : "pack 1"}, values : [{ item : { id : 1 , name : "item1"}, itemP : {id : 2 , name : "itemP12"} }, { item : { id : 4 , name : "item4"}, itemP : {id : 2 , name : "itemP12"} }] }]; const mutatedArray = nullifyDupes(originalArray); console.log(mutatedArray);

Answer 4

您可以使用.map()将数组元素映射到不包含重复项的数组对象。 对于.map()每次迭代，您可以再次将.map()用于内部值数组以将其转换为对象数组，以便将重复项转换为null 。 在这里，我保留了一个seen对象，它跟踪所见的属性及其字符串化值。 通过循环遍历对象中的所有属性（使用for...of ），您可以通过使用seen对象确定键值对之前是否已经看到。

这种方法的优点是它不仅适用于一个属性（即不仅仅是itemP ），而且适用于任何其他重复的键值对。

请参阅下面的示例：

 const array = [{key:{id:1,pack:"pack 1"},values:[{item:{id:1,name:"item1"},itemP:{id:2,name:"itemP12"}},{item:{id:4,name:"item4"},itemP:{id:2,name:"itemP12"}}]}]; const seen = {}; const res = array.map(obj => { obj.values = obj.values.map(vobj => { for (let p in vobj) { vobj[p] = seen[p] === JSON.stringify(vobj[p]) ? null : vobj[p]; seen[p] = seen[p] || JSON.stringify(vobj[p]); } return vobj; }); return obj; }); console.log(res);

对于刚刚从数组中的所有对象中删除itemP的方法，您可以使用：

 const array = [{key:{id:1,pack:"pack 1"},values:[{item:{id:1,name:"item1"},itemP:{id:2,name:"itemP12"}},{item:{id:4,name:"item4"},itemP:{id:2,name:"itemP12"}}]}]; let itemP = ""; const res = array.map(obj => { obj.values = obj.values.map(vobj => { vobj.itemP = itemP ? null : vobj.itemP; if('itemP' in vobj) { itemP = itemP || JSON.stringify(vobj.itemP); } return vobj; }); return obj; }); console.log(res);