Javascript 递归地将包含子对象的对象解析为键值格式对象

考虑到我得到了这样一个物体：

const o={
名称：'name1'，
年龄:1,，
儿童：[{
名称：'name21'，
年龄:21岁，
儿童：[{
姓名：'name31'，
年龄:31岁，
儿童：[]
}]
}, {
姓名：'name22'，
年龄:22,，
儿童：[]
}]
}

它有三个属性，children属性可以是一个空数组，表示它没有子级。我想将此对象转换为以下格式：

const newObject={
名称1_1：{
名称21_21：{
名称31_31:{}
}, 
姓名22_22:{}
}
}

键的格式为

name\u key

，值将是其相关的子项，如果对象没有子项，则值将只是一个空对象

以下是我的实现：

const o={
名称：'name1'，
年龄:1,，
儿童：[{
名称：'name21'，
年龄:21岁，
儿童：[{
姓名：'name31'，
年龄:31岁，
儿童：[]
}]
}, {
姓名：'name22'，
年龄:22,，
儿童：[]
}]
}
const parser=obj=>{
常量结果={}
常量{name，age}=obj
常量键=`${name}{age}`
如果（obj.children.length>0）{
obj.children.forEach（child=>{
结果[键]=分析器（子级）
})
}否则{
结果[键]={}
}
返回结果
}
log（parser（o））/{“name1_1”：{“name22_22”：{}}

您可以将递归调用函数的结果分配给当前对象，但在此之前，如果该对象不存在，您还应该初始化该对象

const o={“name”：“name1”，“age”：1，“children”：[{“name”：“name21”，“age”：21，“children”：[{“name”：“name31”，“age”：31，“children”：[]}，{“name”：“name22”，“age”：22，“children”：[]}
常量解析器=（{name，age，children}）=>{
常量结果={}
常量键=`${name}{age}`；
如果（！result[key]）result[key]={}
if（儿童长度）{
children.forEach（child=>{
赋值（结果[键]，解析器（子））
})
}
返回结果；
}
log（parser（o））

您可以将递归调用函数的结果分配给当前对象，但在此之前，如果该对象不存在，您还应该初始化该对象

const o={“name”：“name1”，“age”：1，“children”：[{“name”：“name21”，“age”：21，“children”：[{“name”：“name31”，“age”：31，“children”：[]}，{“name”：“name22”，“age”：22，“children”：[]}
常量解析器=（{name，age，children}）=>{
常量结果={}
常量键=`${name}{age}`；
如果（！result[key]）result[key]={}
if（儿童长度）{
children.forEach（child=>{
赋值（结果[键]，解析器（子））
})
}
返回结果；
}
log（parser（o））

在您的实现中，

result[key]=parser（child）

在第二次迭代中重写对象以设置

result[key]={name22\u 22:{}

。因此，解决方法是扩展

结果[key]

对象，而不是重新分配

const o={
名称：'name1'，
年龄:1,，
儿童：[{
名称：'name21'，
年龄:21岁，
儿童：[{
姓名：'name31'，
年龄:31岁，
儿童：[]
}]
}, {
姓名：'name22'，
年龄:22,，
儿童：[]
}]
}
const parser=obj=>{
常量结果={}
常数{
名称
年龄
}=obj
常量键=`${name}{age}`
如果（obj.children.length>0）{
obj.children.forEach（child=>{
//结果[键]=解析器（子级）；
结果[键]={
…结果[键]，
…解析器（子级），
}
})
}否则{
结果[键]={}
}
返回结果
}
console.log（parser（o））/{name1_1:{name21_21:{name31_31:{}}，name22_22:{}}

在您的实现中，

result[key]=parser（child）

在第二次迭代中重写对象，以设置

result[key]={name22_22:{}

。因此，解决方法是扩展

结果[key]

对象，而不是重新分配

const o={
名称：'name1'，
年龄:1,，
儿童：[{
名称：'name21'，
年龄:21岁，
儿童：[{
姓名：'name31'，
年龄:31岁，
儿童：[]
}]
}, {
姓名：'name22'，
年龄:22,，
儿童：[]
}]
}
const parser=obj=>{
常量结果={}
常数{
名称
年龄
}=obj
常量键=`${name}{age}`
如果（obj.children.length>0）{
obj.children.forEach（child=>{
//结果[键]=解析器（子级）；
结果[键]={
…结果[键]，
…解析器（子级），
}
})
}否则{
结果[键]={}
}
返回结果
}
log（parser（o））/{name1_1:{name21_21:{name31_31:{}}}，name22_22:{}}

已经有一个很好的答案解释了您做错了什么以及如何修复它。但我觉得你在这里工作太辛苦了。让递归完成繁重的工作，并使用

Object.assign

将事物粘合在一起。这样就可以实现如下简单的实现：

const解析器=（{name，age，children}）=>
（{[`${name}}{age}`]：Object.assign（{}，…（children | |[]）.map（解析器）））
const o={name:'name1'，年龄：1，子项：[{name:'name21'，年龄：21，子项：[{name:'name31'，年龄：31，子项：[]}，{name:'name22'，年龄：22，子项：[]}
log（parser（o））

已经有一个很好的答案解释了您做错了什么以及如何修复它。但我觉得你在这里工作太辛苦了。让递归完成繁重的工作，并使用

Object.assign

将事物粘合在一起。这样就可以实现如下简单的实现：

const解析器=（{name，age，children}）=>
（{[`${name}}{age}`]：Object.assign（{}，…（children | |[]）.map（解析器）））
const o={name:'name1'，年龄：1，子项：[{name:'name21'，年龄：21，子项：[{name:'name31'，年龄：31，子项：[]}，{name:'name22'，年龄：22，子项：[]}
console.log（解析器（o））

干杯，兄弟。所以我做错的是我使用了

result[key]=parser（child）

，这样

result

每次都会被