Javascript 用嵌套对象展平阵列

我有一个包含对象的数组，它可以有子对象，子对象和父对象具有相同的结构，基本上就是对象嵌套

我想知道如何将对象的结构展平，以便获得所有对象的id，包括嵌套对象的id。

例如，这个结构

const data = [
  {
    id: 2,
    children: [
      {
        id: 1,
        children: []
      }
    ]
  },
  {
    id: 3,
    children: [],
  }
]

应该被夷为平地

const data = [2,1,3]

我试过了

---

使用Array.reduce（）和object spread语法，但我无法理解执行此操作所需的逻辑。

您可以使用

JSON.stringify

，对于

id

的每个键，按下一个数组：

const数据=[
{
id:2，
儿童：[
{
id:1，
儿童：[]
}
]
},
{
id:3，
儿童：[]，
}
]
常量ID=[]；
stringify（数据，（键，val）=>{
如果（键=='id'）{
id.push（val）；
}
返回val；
});
控制台日志（ids）这是一个递归作业。在数组上循环，对于数组中的每个元素，将id推入一个新数组，并对子元素重复此操作


const数据=[{
id:2，
儿童：[{
id:1，
儿童：[]
}]
},
{
id:3，
儿童：[]，
}
];
console.log（展平（数据））；
函数展平（数据）{
常量结果=[]；
递归（数据）；
返回结果；
函数递归（数据）{
data.forEach（成员=>{
结果推送（成员id）；
递归（成员：儿童）；
});
}
}
您可以执行一些递归方法

function flatArr(arr, res) {
  // iterate over the array
  arr.forEach(o => {
    // check id is present then push it into the result array
    if ('id' in o) res.push(o.id)
    // check children is present and non-empty
    // then ecursively call the function
    if (o.children && o.children.length) flatArr(o.children, res);
  })
  // return the result array(optional)
  return res;
}

console.log(flatArr(data, []));


const数据=[{
id:2，
儿童：[{
id:1，
儿童：[]
}]
},
{
id:3，
儿童：[]，
}
];
函数flatArr（arr，res）{
//迭代数组
arr.forEach（o=>{
//检查id是否存在，然后将其推入结果数组
如果（o中的“id”）恢复推送（o.id）
//检查子项是否存在且不为空
//然后ecursive调用该函数
if（o.children&&o.children.length）flatArr（o.children，res）；
})
//返回结果数组（可选，因为它与最初传递的数组引用相同）
返回res；
}
log（flatArr（数据，[]）您可以通过使用实际id并获取其子对象来减少对象数组


const
getId=array=>array.reduce(
（r，{id，children}）=>[…r，id，…getId（children）]，
[]
),
数据=[{id:2，子项：[{id:1，子项：[]}，{id:3，子项：[]}，
ids=getId（数据）；
控制台日志（ids）
您可以使用递归方法，对每个
子项进行迭代，并将所有
id
推送到一个数组中


const data=[{id:2，子项：[{id:1，子项：[]}，{id:3，子项：[]，}，
getId=（data）=>data.reduce（（r，{id，children}）=>r.concat（id，getId（children）），[]）；
console.log（getId（data））
const数据=[
{
id:2，
儿童：[
{
id:1，
儿童：[]
}
]
},
{
id:3，
儿童：[]，
}
]
const getid=（data）=>data.map（d=>[d.id，…getid（d.children）]）.flat（）
console.log（getIds（data））
您可以使用递归。请注意，下面的代码引用传递了
arr
，因此我们可以直接
push（）
ids到它，而无需获取
返回值


const data=[{id:2，子项：[{id:1，子项：[]}，{id:3，子项：[]，}]
函数getIds（数据，arr）{
//迭代chilren数组
for（数据的子对象）{
//将每个子级的id添加到arr
arr.push（子id）；
//检查子级是否让子级将其“ID”添加到同一数组
if（child.children）getid（child.children，arr）；
}
//最后返回数组
返回arr；
}
log（getid（data，[]））
我不喜欢递归：）

请注意另一个严格化答案-ILST



const data=[{id:2，子项：[{id:1，子项：[]}，{id:3，子项：[]，}]；
console.log(
JSON.stringify（数据）
.match（/（？：“id:）（\d+）/g）
.map（v=>+v.replace（/“id”：/g，”））
)
另一个版本。不是最漂亮的，但能完成任务：


const数据=[
{
id:2，
儿童：[
{
id:1，
儿童：[]
}
]
},
{
id:3，
儿童：[]，
}
];
让mappedArray=data.map（num=>[].concat（num.children.map（child=>child.id））.concat（num.id））；
mappedArray=[].concat.apply（[]，mappedArray）；
控制台日志（Mappedaray）将每个值转换为
数字
。非常奇怪的解决方案+1@MaheerAli完成；）这很优雅，我接受了这个答案，就像那一行！谢谢，太酷了。我不知道stringify接受了参数。我还使用了stringify，然后是一个regex，奇怪的是，它不会递归：
JSON.stringify（数据，[“id]”）