Javascript 递归搜索数组中的嵌套对象并更新其子对象

我试图通过对象的唯一id在数组中递归搜索对象，然后将对象推入其部分数组，然后返回整个数组

例如，这是我要搜索的数组：

car =    [
    {
        id: 13,
        title: 'Component13',
        parts: [
           {
               id: 784,
               title: 'Component242',
               parts: [

               ]
           },
           {
               id: 9,
               type: 'mitigation',
               parts: [
                      {
                          id: 68,
                          type: 'mitigation22',
                          parts: [

                          ]
                      },
                      {
                          id: 88,
                          type: 'threat',
                          parts: [

                          ]
                      }
                ]
           }
      ]
},
{
    id: 3,
    title: 'Component13',
    parts: [
           {
               id: 60,
               title: 'Component34',
               parts: [

               ]
           },
           {
               id: 51,
               type: 'threat',
               parts: [
                      {
                           id: 38,
                           type: 'mitigation22',
                           parts: [

                           ]
                     }
               ]
          }
      ]
   }
]

如果我想将此对象插入id 38中的部分子数组：

{
    id: 34,
    title: 'Component211',
    parts: [

    ]
}

。。。结果应该是：

  ...commented out the first block to save space
 {
    id: 3,
    title: 'Component13',
    parts: [
          {
              id: 60,
              title: 'Component34',
              parts: [

              ]
          },
          {
              id: 51,
              type: 'threat',
              parts:[
                   {
                        id: 38,
                        type: 'mitigation22',
                        parts: [
                             {
                                 id: 34,
                                 title: 'Component211',
                                 parts: [

                                 ]
                            }
                        ]
                  }
            ]
      }
   ]
}

考虑到我可能需要在汽车阵列的任何级别插入一个对象，最好的方法是什么

我无力的尝试：

 const updatePart = (id, obj, car) => {
    for (var i = 0; i < car.length; i++) {
        if (car[i].id == id) {
            car[i].parts.push(obj)
        } else {
            car[i].parts.map(function (item) {
                updatePart(id, obj, item)
            })
        }
        return car
    }
}

car = updateTree(id, obj, car);

const updatePart=（id、obj、car）=>{
对于（变量i=0；i
也许考虑一个查找对象来存储对树中节点的引用的扁平列表：
let memo = {};
const buildMemo = (arr) => {
  arr.forEach(item => {
    memo[item.id] = item;
    if (item.parts) buildMemo(item.parts);
  }
};
buildMemo(car);

现在，如果您需要在id=34的
car
树的节点上执行一些操作，您可以从memo[34]获得一个引用。如果从
car
数组中添加/删除/移动节点，则需要更新memo的逻辑，因为
updatePart
需要一个数组，但在
映射中使用的是递归发送对象。因此，您根本不需要使用
map
（或
forEach
，这在这里最合适）：


var-car=[{id:13，标题：“组件13”，部分：[{id:784，标题：“组件242”，部分：[]}，{id:9，类型：“缓解”，部分：[{id:68，类型：“缓解22”，部分：[]}，{id:88，类型：“威胁”，部分：[]}，{id:3，标题：“组件13”，部分：[{id:60，标题：“组件34”，部分：[]}，{id:51，类型：“威胁”，部分：[id:38，类型：“缓解22”，部分：[]}；
const updatePart=（id、obj、car）=>{
对于（变量i=0；iconsole.log（car）
如果你想得到一个新的数组，你可以用新的
部分
属性映射对象


const
update=（数组，id，object）=>array.map（o=>o.id==id
？{…o，部件：[…o.部件，对象]}
：{…o，parts:update（o.parts，id，object）}
);
var car=[{id:13，标题：'Component13'，零件：[{id:784，标题：'Component242'，零件：[]}，{id:9，类型：'Migration'，零件：[{id:68，类型：'Migration22'，零件：[]}，{id:88，类型：'threat'，零件：[]}}，{id:3，标题：'Component13'，零件：[{id:60，标题：'Component34'，零件：[]}，{id:51，类型：'threat'，零件：[{id:38，键入：“缓解22”，部分：[]}]}，
结果=更新（car，38，{id:34，标题：'Component211'，零件：[]}）；
console.log（结果）；
.as console wrapper{max height:100%！important；top:0；}
IMO没有理由返回整个数组。您只需使用此函数修改它，而无需
car=updateTree（id，obj，car）；
您只需
car=updateTree（id，obj，car）
另外，您定义了
updatePart
函数，但调用了未定义的
updateTree
。顺便说一句，没有理由使用
.map
和
for
循环，而不仅仅是
。在这两种情况下，forEach
函数。您想对数组进行变异还是用更新的项获得一个新数组？谢谢您的回答