使用JavaScript从对象中删除

我有一个对象，如图所示：

const arr = [
  {
    name: 'FolderA',
    child: [
      {
        name: 'FolderB',
        child: [
          {
            name: 'FolderC0',
            child: [],
          },
          {
            name: 'FolderC1',
            child: [],
          },
        ],
      },
    ],
  },
  {
    name: 'FolderM',
    child: [],
  },
];

我的路径是字符串：

var path = "0-0-1".

我必须删除该对象：

{
    name: 'FolderC1',
    child: [],
 },

我可以这样做

arr[0].child[0].splice(1, 1);

---

但我想动态地做。由于路径字符串可以是任何内容，我希望动态创建上面的“.”运算符和拼接定义，以便在特定位置进行拼接。

您可以拆分

路径并使用这些部分，如下所示：

let path = '0-0-1';
let parts = path.split('-');

// Call your splice using your parts (unsure if your '1' is the index, or deleteCount).

// If parts[2] is the index
arr[parts[0]].child[parts[1]].splice(parts[2], 1);

// If parts[2] is the deleteCount:
arr[parts[0]].child[parts[1]].splice(1, parts[2]);

您可以通过保存最后一个索引并返回实际索引的子级来减少索引。稍后与最后一个索引进行拼接


功能（阵列、路径）{
var索引=路径分割（'-'），
last=index.pop（）；
指数
.reduce（（a，i）=>a[i]。子级，数组）
.拼接（最后一个，1）；
}
常量数组=[{name:'FolderA'，子项：[{name:'FolderB'，子项：[{name:'FolderC0'，子项：[]}，{name:'FolderC1'，子项：[]}，{name:'FolderM'，子项：[]}；
深度拼接（阵列，“0-0-1”）；
console.log（数组）
.as console wrapper{max height:100%！important；top:0；}
如果路径总是由3个（或更少）索引组成，您可以像下面这样轻松完成：


函数deleteByPath（arr，path）{
const index=path.split（'-'）.map（（x）=>+x）；
如果（索引长度<1）{
返回null；
}else if（1==index.length）{
返回阵列拼接（索引[0]，1）；
}else if（2==index.length）{
返回arr[index[0].子拼接（index[1]，1）；
}否则{
返回arr[index[0]].child[index[1].child.splice（index[2]，1）；
}
}
常数arr=[
{
名称：“福尔德拉”，
儿童：[
{
名称：“FolderB”，
儿童：[
{
名称：'FolderC0'，
子项：[]，
},
{
名称：“FolderC1”，
子项：[]，
},
],
},
],
},
{
名称：“FolderM”，
子项：[]，
},
];
日志（deleteByPath（arr，“0-0-1”）；
日志（deleteByPath（arr，“0-1”）；
log（deleteByPath（arr，“0”））您可以编写一个递归函数，该函数沿层次结构向下移动，直到路径可用为止。下面是一个非常小的片段


const arr=[
{
名称：“福尔德拉”，
儿童：[
{
名称：“FolderB”，
儿童：[
{
名称：'FolderC0'，
子项：[]，
},
{
名称：“FolderC1”，
子项：[]，
},
],
},
],
},
{
名称：“FolderM”，
子项：[]，
},
];
设ar_path=“0-0-1”；
函数deleteRecursive（arr，path）{
if（Array.isArray（arr）&&path.length>0）{
常量索引=编号（path.shift（））；
如果（路径长度>0）
deleteRecursive（arr[index].子级，路径）
其他的
arr.slice（索引，1）；
}否则{
console.log（'invalid'）；
}
}
deleteRecursive（arr，ar_path.split（'-'））
控制台日志（arr）
//变量设置：
常数arr=[
{
名称：“福尔德拉”，
儿童：[
{
名称：“FolderB”，
儿童：[
{
名称：'FolderC0'，
子项：[]，
},
{
名称：“FolderC1”，
子项：[]，
},
],
},
],
},
{
名称：“FolderM”，
子项：[]，
},
];
const path=“0-0-1”；
//将路径拆分为多个部分以进行迭代：
const pathArray=path.split（“-”）；
//Javascript分配是通过引用进行的，因此arrayToManage将成为原始数组中的一个内部部分
让arrayToManage=arr；
//我们将遍历数组的子元素，直到到达要删除的位置
而（pathArray.length>1）{
const key=parseInt（pathArray.shift（））；
arrayToManage=arrayToManage[key]。子级；
}
//获取最后一个数组的最后一个位置，即要删除该项的位置
const key=parseInt（pathArray.shift（））；
阵列管理。拼接（键，1）；
//因为这都是通过引用进行的，所以我们对arrayToManage所做的更改实际上是在arr对象上进行的
log（“最终结果：，JSON.stringify（arr））否，路径可以是任意长度：）@MichaelPhilips，更新答案以处理1、2或3部分的路径。您可以根据示例的需要添加更多案例。我希望是动态的，我不知道嵌套路径的长度：arr[parts[0]].child[parts[1]].splice（1，parts[2]）；您的
0-0-1
字符串的长度/深度是否发生变化？请查看