Javascript-从嵌套数组中删除对象

我有一个对象数组，每个对象都必须有键和标题，但子对象是可选的，它可以嵌套，我可以多次在子对象中包含子对象。我想通过提供的键值（例如键677）删除一些对象。我尝试了过滤器，但我只删除了第一级。我也尝试过递归，但不确定是否正确

const数据=[{
键：“1”，
标题：“标题1”，
儿童：[{
键：“098”，
标题：“嘿”，
儿童：[{
键：“677”，
标题：“儿童”
}]
}]
},
{
键：“123”，
标题：“瓷砖111”
},
{
键：“345”，
标题：“某物”
}
];
常数rem='677'；
常数del=（el）=>{
如果（！el.children）{
返回el.key！==rem；
}否则{
如果（el.key！==rem）{
del（el.儿童）；
返回el；
}
}
};
常数res=数据过滤器（（el）=>{
返回del（el）；
});
控制台日志（res）我猜您现有的解决方案如下

const data = [
  {
    key: '1',
    title: 'title 1',
    children: [{
      key: '098',
      title: 'hey',
      children: [{ key: '677', title: 'child'}]
    }]
  },
  { key: '123', title: 'tile 111' },
  { key: '345', title: 'something' }
];

function removeByKey(arr, removingKey){
  return arr.filter( a => a.key !== removingKey);
}

因此，它在第一个层次上起作用，但并不深入

只要换成那样就行了

function removeByKey(arr, removingKey){
  return arr.filter( a => a.key !== removingKey).map( e => {
    return { ...e, children: removeByKey(e.children || [], removingKey)}
  });
}

没有什么警告，对于没有任何子项的每个项，children属性都不会设置为[]

那么它是如何工作的呢？我们不保留可接受的项目，而是使用
{…e}
创建一个副本，在本例中，它相当于
{key:e.key，title:e.title，children:e.children}

我们知道强制使用
removeByKey（例如children | |[]，removingKey）
重写属性children，因此我们递归调用该方法。函数无法正常工作。
您可以使用一些简单的递归来完成以下操作：

const data = [
  {
    key: '1',
    title: 'title 1',
    children: [
     {
      key: '098',
      title: 'hey',
      children: [{ key: '677', title: 'child'}]
     }
    ]
  },
  { key: '123', title: 'tile 111' },
  { key: '345', title: 'something' }
];

function removeByKey(key, arr) {
  // loop through all items of array
  for(let i = 0; i < arr.length; i++) {
    // if array item has said key, then remove it
    if(arr[i].key === key) {
      arr.splice(i, 1);
    } else if(typeof(arr[i].children) !== "undefined") {
      // if object doesn't have desired key but has children, call this function 
      // on the children array
      removeByKey(key, arr[i].children);
    }
  }
}

removeByKey('098', data);

console.log(data);

const数据=[
{
键：“1”，
标题：“标题1”，
儿童：[
{
键：“098”，
标题：“嘿”，
子项：[{key:'677'，title:'child'}]
}
]
},
{键：'123'，标题：'tile 111'}，
{键：'345'，标题：'something'}
];
功能移除键（键，arr）{
//循环遍历数组的所有项
for（设i=0；i

这可能比提供的另一个答案更容易理解。
我将使用递归方法处理findIndex和splice。使用
some
将允许代码退出，而无需运行整个树


const数据=[{
键：“1”，
标题：“标题1”，
儿童：[{
键：“098”，
标题：“嘿”，
儿童：[{
键：“677”，
标题：“儿童”
}]
}]
},
{
键：“123”，
标题：“瓷砖111”
},
{
键：“345”，
标题：“某物”
}
];
常量removeKey=（数据，键）=>{
//查看对象是否存在
const index=data.findIndex（x=>x.key==key）；
如果（索引>-1）{
data.splice（索引，1）；//删除对象
返回真值
}否则{
//循环遍历数组的索引，直到找到一个带有键的索引
返回数据。一些（x=>{
如果（x.儿童）{
返回removeKey（x.children，key）；
}否则{
返回false；
}
})
}
}
log（removeKey（数据'677'））
log（JSON.stringify（data））1。第一个子项出现语法错误-子项现在是数组。2.发布你想要的结果。你的顶级
子对象
是一个对象数组，所以添加花括号你尝试过递归解决方案吗？如果你发布了只在第一级工作的过滤代码也会很好。