Javascript 删除嵌套数组中具有键值的对象

我想删除每个部分下唯一的低级对象（例如，在下面的代码中，在个人数据下有两个对象…我想删除一个对象，其中action:old），其中“action”：“old”

我在我的项目中使用lodash

[
  {
    "clientDetails": {
      "personalData": [
        {
          "action": "NEW",
          "id": "12345"
        },
        {
          "action": "OLD",
          "id": "12445"
        }
      ]
    },
    "clientAddress": {
      "primaryAddress": [
        {
          "action": "OLD",
          "id": "12345"
        },
        {
          "action": "NEW",
          "id": "12445"
        }
      ],
      "secondaryAddress": [
        {
          "action": "NEW",
          "id": "12345"
        },
        {
          "action": "OLD",
          "id": "12445"
        }
      ]
    }
  },
  {
    "clientDemise": {
      "deathDetails": [
        {
          "action": "NEW",
          "id": "12345"
        },
        {
          "action": "OLD",
          "id": "12445"
        }
      ]
    },
    "clientMarital": {
      "divorceInformation": [
        {
          "action": "OLD",
          "id": "12345"
        },
        {
          "action": "NEW",
          "id": "12445"
        }
      ],
      "marraigeInformation": [
        {
          "action": "NEW",
          "id": "12345"
        },
        {
          "action": "OLD",
          "id": "12445"
        }
      ]
    }
  }
]

---

对于错误的演示，很抱歉，这是我第一次发布问题

如果您的数据结构相当一致（即与您在问题中包含的内容类似），您可以这样做：

const mapObj=（f，obj）=>{
返回Object.keys（obj）.reduce（（acc，key）=>{
acc[键]=f（obj[键]，键）
返回acc
}, {})
}
常量过滤器数据=数据=>{
//数据本身是一个数组，因此迭代数组中的每个项
返回data.map（x1=>{
//x1是一个对象，因此需要迭代对象中的每个项
返回mapObj（x2=>{
//x2是一个对象，因此需要迭代对象中的每个项
返回mapObj（x3=>{
//x3是一个对象数组。数组中的每个项都有一个动作键，可以等于“NEW”或“OLD”。获取动作为“OLD”的项的rido
返回x3.filter（x4=>x4.action！==“OLD”）
}，x2）
}，x1）
})
}
常数数据=[
{
“客户详细信息”：{
“个人数据”：[
{
“行动”：“新”，
“id”：“12345”
},
{
“动作”：“老”，
“id”：“12445”
}
]
},
“客户地址”：{
“主要地址”：[
{
“动作”：“老”，
“id”：“12345”
},
{
“行动”：“新”，
“id”：“12445”
}
],
“第二地址”：[
{
“行动”：“新”，
“id”：“12345”
},
{
“动作”：“老”，
“id”：“12445”
}
]
}
},
{
“客户死亡”：{
“死亡详情”：[
{
“行动”：“新”，
“id”：“12345”
},
{
“动作”：“老”，
“id”：“12445”
}
]
},
“当事人婚姻”：{
“离婚信息”：[
{
“动作”：“老”，
“id”：“12345”
},
{
“行动”：“新”，
“id”：“12445”
}
],
“婚姻信息”：[
{
“行动”：“新”，
“id”：“12345”
},
{
“动作”：“老”，
“id”：“12445”
}
]
}
}
]
常量结果=过滤器数据（数据）
log（结果）

您可以使用JavaScript过滤器。通过不使用lodash来减少捆绑包的大小

// it's upto you, you can use new Array() as well and insert if(ktm.action==='NEW')
clients = clients.filter(function(itm) {
  Object.keys(itm).forEach(function(Okey, Ovalue) {
    Object.keys(itm[Okey]).forEach(function(inkey, invalue) {
      itm[Okey][inkey].filter(function(ktm) {
        if (ktm.action === 'OLD') {
          // perform your logic, either you can insert into new Array() or 
          // delete that object and return clients
        }
      });
    });
  });
});

---

考虑到这一点，只有几行代码可以实现这一点

input = your input

这种代码的和平将完成这项工作

for (var i of input) {
  for (var j in i) {
   var ob = i[j];
   for (var k in ob) {
     var index = _.findIndex(ob[k], {'action': 'OLD'});
     if (index > -1) {
       ob[k].splice(index, 1);
     }
   }
 }
}

---

您可以进行如下深度复制：

    const array = [
      {
        "clientDetails": {
          "personalData": [
            {
              "action": "NEW",
              "id": "12345"
            },
            {
              "action": "OLD",
              "id": "12445"
            }
          ]
        },
        "clientAddress": {
          "primaryAddress": [
            {
              "action": "OLD",
              "id": "12345"
            },
            {
              "action": "NEW",
              "id": "12445"
            }
          ],
          "secondaryAddress": [
            {
              "action": "NEW",
              "id": "12345"
            },
            {
              "action": "OLD",
              "id": "12445"
            }
          ]
        }
      },
      {
        "clientDemise": {
          "deathDetails": [
            {
              "action": "NEW",
              "id": "12345"
            },
            {
              "action": "OLD",
              "id": "12445"
            }
          ]
        },
        "clientMarital": {
          "divorceInformation": [
            {
              "action": "OLD",
              "id": "12345"
            },
            {
              "action": "NEW",
              "id": "12445"
            }
          ],
          "marraigeInformation": [
            {
              "action": "NEW",
              "id": "12345"
            },
            {
              "action": "OLD",
              "id": "12445"
            }
          ]
        }
      }
    ]    
    function removeOldAction(a) {
    if (a instanceof Array) {
        let copiee = [];
        for (let item in a) {
            const propValue = removeOldAction(a[item]);
            if(propValue) {
                copiee.push(propValue);
            }
        }
        return copiee;
    }
    if (a instanceof Object) {
        if (a['action'] === 'OLD') { 
            return; 
        }
        let copiee = {};
        for (let key in a) {
            copiee[key] = removeOldAction(a[key]);
        }
        return copiee;
    } 
    return a;
}

    console.log(removeOldAction(array));

---

您可以通过类似的方式实现这一点，而无需使用lodash：

var data=[{“clientDetails”：[{“action”：“NEW”，“id”：“12345”}，{“action”：“OLD”，“id”：“12445”}}，{“clientAddress”：{“primaryAddress”：[{“action”：“OLD”，“id”：“12345”}，{“action”：“NEW”，“id”：“12445”}，{“secondaryAddress”：[{“action”：“NEW”，“id”：“12345”}，{“action”：“OLD”：“12445”}，}，}，}，{“客户死亡”：{“死亡细节”：[{“行动”：“新”，“身份”：“12345”}，{“行动”：“旧”，“身份”：“12445”}]}，{“离婚信息”：[{“行动”：“旧”，“身份”：“12345”}，{“行动”：“新”，“身份”：“12445”}]，“婚姻信息”：[{“行动”：“新”，“身份”：“12345”}，{“行动”：“旧”，“身份”：“12445”}]
const removeOld=（数据）=>data.map（x=>
Object.entries（x）.reduce（（r[k，v]）=>{
r[k]=Object.entries（v.map）（[o，p]）=>
（{[o]：p.filter（n=>n.action！='OLD'）}）
返回r
},{}))
console.log（删除旧数据））

---

独立于结构的解决方案检查每个对象节点中的操作

var data=[{clientDetails:{personalData:[{action:“新”，id:“12345”}，{action:“旧”，id:“12445”}}，客户地址：{primaryAddress:[{action:“旧”，id:“12345”}，第二地址：[{action:“新”，id:“12345”}，{action:“旧”，id:“12445”}，{clientdeathDetails:{action:{action:“新”，id:“12345”}，id:“旧”}，id:{，客户婚姻：{离婚信息：{行动：“旧”，身份证：“12345”}，{行动：“新”，身份证：“12445”}，{婚姻信息：{行动：“新”，身份证：“12345”}，{行动：“旧”，身份证：“12445”}，}；
常数减速机=（当前）=>{
如果（uu.isArray（curr））
返回（当前）
.filter（el=>！（&el.action=='OLD'）中的'action'）
.map（el=>减速器（el））
.value（）
否则，如果（u.isObject（当前））{
返回（当前）
.mapValues（el=>减速器（el））
.value（）
}否则
返回货币；
};
console.log（reducer（数据））；

---

让我们不要改变原始输入数据，使用自定义程序克隆它，并拒绝自定义程序中不需要的内容（如果存在），以获得预期的更干净的克隆输出。您可以使用

这只是一个你想要拒绝的东西（硬编码）的例子，但是你可以把它包装在一个回调中，并把拒绝标准作为一个参数，使它成为动态的

现在我们开始：

let input=[{“clientDetails”：{“personalData”：[{“action”：“NEW”，“id”：“12345”}，{“action”：“OLD”，“id”：“12445”}}，{“primaryAddress”：[{“action”：“OLD”，“id”：“12345”}，{“action”：“NEW”，“id”：“12445”}，{“action”：“NEW12345“}，{“动作”：“旧”、“id”：“12445”}，{“离婚信息”：[{“动作”：“旧”、“id”：“12345”}，{“动作”：“新”、“id”：“12445”}]，“婚姻信息”：[{“动作”：“新”、“id”：“12345”}，{“动作”：“旧”、“id”：“12445”}]，
清除=（输入，rej）=>(
_.cloneDeepWith（输入，v=>u.find（v，rej）？u.reject（v，rej）：未定义）
),
物件；
res=clear（输入，{action:“OLD”}）；//您可以过滤掉action:OLD
控制台日志（res）；
res=清除（inp
_.cloneDeepWith(input, v => _.find(v, {action: "OLD"}) ? _.reject(v, {action: "OLD"}) : undefined);