Javascript 如何从两个数组在JS上构建动态对象

我正试图从另外两个数组中构建一个对象数组，有人能帮我吗

const parent =[
  { Id: 1, Cate: 'Accommodation', p_id: null },
  { Id: 4, Cate: 'National Travel', p_id: null }
]

const child =[
  { Id: 2, Cate: 'Hotel Accommodation', p_id: 1 },
  { Id: 3, Cate: 'Own arrangement', p_id: 1 },
  { Id: 5, Cate: 'Air', p_id: 4 },
  { Id: 6, Cate: 'Bus', p_id: 4 },
  { Id: 7, Cate: 'AC Volvo', p_id: 6 },
  { Id: 8, Cate: 'Luxury Bus', p_id: 6 },
  { Id: 9, Cate: 'Bus', p_id: 6 }
]

const data = [
  {
    id: 1,
    tittle: 'Accommodation',
    subItem: [
      { id: 2, tittle: 'Hotel Accommodation', subItems: [] },
      { id: 3, tittle: 'Own arrangement', subItems: [] },
    ],
  },
  {
    id: 4,
    tittle: 'National Travel',
    subItem: [
      { id: 5, tittle: 'Air', subItems: [] },
      {
        id: 6,
        tittle: 'Bus',
        subItem: [
          { id: 7, tittle: 'AC Volvo' },
          { id: 5, tittle: 'Air' },
          { id: 8, tittle: 'Luxury Bus' },
          { id: 9, tittle: 'Bus' },
        ],
      },
    ],
  },
];

parent

和

child

是我从数据库中获取的数据，现在我需要将其更改为类似于

data

的内容。问题是它必须是动态的，因为

子项

可以按需要运行很长时间，我如何才能做出这样的事情？

const parent=[{Id:1，Cate:'住宿'，p_Id:null}，{Id:4，Cate:'国家旅行'，p_Id:null}]；
const child=[{Id:2，Cate:'酒店住宿'，p_Id:1}，{Id:3，Cate:'自己安排'，p_Id:1}，{Id:5，Cate:'空中'，p_Id:4}，{Id:6，Cate:'巴士'，p_Id:4}，{Id:7，Cate:'AC沃尔沃'，p_Id:6}，{Id:8，Cate:'豪华巴士'，p_Id:6}，{Id:9，Cate:'巴士'，p_Id:6}；
函数数据（父级、子级）{
//映射以保存父数组和子数组的所有值
常量映射={}；
//地图保存最终结果
让item={}；
//将父元素添加到映射
for（设i=0；is.id==childCat.p_id）[0][“子项”].push（childCat）；
}
}
}
}
//最后从项目映射返回值。
返回对象。值（项）；
}
const data=prepardata（父级、子级）；
控制台日志（数据）您可以维护两个对象，一个父对象和一个可见对象。SEED对象负责存储所有已看到的对象ID。这意味着，对于数组中的每个对象，将其添加到所看到的对象中

// Seen object
{
  id_1: {id: id_1, ...}, /* id: 1 */
  id_2: {id: id_2, ...}, /* id: 2 */
  id_3: {id: id_3, ...}, /* id: 3 */
  id_4: {id: id_3, ...}  /* id: 4 */
}

由于父对象先于子对象使用，您可以说，当
p_id
未出现在
seen
对象中时，当前对象是父对象，因此，您可以将其
id
添加到
父对象中（在上面的示例中，假设
id_1
是父对象）。请记住，此对象也会添加到
seen
，因此，我们可以使用其引用在
seen
中的父对象和
父对象之间创建链接：

// Parents object
{
  id_1: /* ref: 1 */ <-- this refers to the seen[id_1] object
}

通过使用
.push（seen[id]）
将添加到
seen
的对象推入，我们添加id_2作为引用。我们正在添加一个引用，因为这意味着，如果我们在看到的对象中更改存储在id_2中的对象，那么它的更改将反映在id_1的子项数组中

迭代完数组中的所有对象后，我们可以获取父对象的值，该对象包含对
seen
中对象的引用，这些对象本身也（可能）包含对
seen
中其他对象的引用。这给了我们最终的结果：


const parent=[{Id:1，Cate:'住宿'，p_Id:null}，{Id:4，Cate:'国家旅行'，p_Id:null}]；
const child=[{Id:2，Cate:'酒店住宿'，p_Id:1}，{Id:3，Cate:'自己安排'，p_Id:1}，{Id:5，Cate:'空中'，p_Id:4}，{Id:6，Cate:'巴士'，p_Id:4}，{Id:7，Cate:'AC沃尔沃'，p_Id:6}，{Id:8，Cate:'豪华巴士'，p_Id:6}，{Id:9，Cate:'巴士'，p_Id:6}；
const buildChildren=arr=>{
const parents={}，seen={}；
for（arr的常数{Id，Cate，p_Id}）{
seen[Id]={Id:Id，title:Cate}；
如果（见p_id）{
const myParent=seen[p_id]；
myParent.subItem=myParent.subItem | |[]；//如果子项属性尚不存在，请添加子项属性
myParent.subItem.push（参见[Id]）；
}else{//添加新的父级
父母[Id]=被看见的[Id]；
}
}
返回Object.values（父对象）；
}
log（buildChildren（[…parent，…child]）更简洁、更详细的解释（基于）

此外，问题是
item.Id
确保它应该按升序排序


主要思想是：

将
“父项”
推入
结果中

//If the first meet item with `parent ID` doesn't exist in store yet, then it should be the parent item
if(!parentItemInStore) 
   result.push(store[Id]); // Adding a new parent


将
子项
添加到
“父项”
。通过使用，我们可以修改项目以及反映参考项目

else { // add subItem
   parentItemInStore.subItem ??= []; // Using `logical nullish assignment` to initialize subItem
   parentItemInStore.subItem.push(store[Id]); 
 }



const parent=[{Id:1，Cate:'住宿'，p_Id:null}，{Id:4，Cate:'国家旅行'，p_Id:null}]；
const child=[{Id:2，Cate:'酒店住宿'，p_Id:1}，{Id:3，Cate:'自己安排'，p_Id:1}，{Id:5，Cate:'空中'，p_
else { // add subItem
   parentItemInStore.subItem ??= []; // Using `logical nullish assignment` to initialize subItem
   parentItemInStore.subItem.push(store[Id]); 
 }