Javascript 如何在json中添加递归函数的结果？

我有一个json：

[
    {
      "question": "1.1",
      "level": 1,
      "id": 4,
      "answers": [
        {
          "text_answer": "NO",
          "questions": [
            {
              "question": "1.1.1",
              "level": 2,
              "id": 3,
              "answers": []
            }
          ]
        },
        {
          "text_answer": null,
          "questions": [
            {
              "question": "1.1.2",
              "level": 2,
              "id": 2,
              "answers": [
                {
                  "text_answer": "SI",
                  "questions": [
                    {
                      "question": "1.1.2.1",
                      "level": 3,
                      "id": 1,
                      "answers": []
                    }
                  ]
                }
              ]
            }
          ]
        }
      ]
    }
  ]

这个

json

是动态的，在

answers

和

questions

字段下可以有

n

个级别，这就是为什么需要使用

递归

函数来检查它们的原因

我希望获得以下输出：

[
      {
        "question": "1.1",
        "level": 1,
        "id": 4,
        "children": [
          {
            "question": "1.1.1",
            "text_answer": "NO",
            "level": 2,
            "id": 3,
            "children": []
          },
          {
            "question": "1.1.2",
            "text_answer": null,
            "level": 2,
            "id": 2,
            "children": [
              {     
                "question": "1.1.2.1",  
                "text_answer": "SI",
                "level": 3,
                "id": 1,
                "children": []
              }
            ]
          }
        ]
      }
]

字段

答案

和

问题

不再存在，它们被重命名为

子项

，并且两者的内容是统一的

我认为这个

递归

函数应该对每个执行双重

操作，但我不知道怎么做

function format(d) {
 if (d.respuestas) {
  d.respuestas.forEach((d) => {
    format;
  });
 }
}
format(data);


var数据=[
{
“问题”：“1.1”，
"一级",，
“id”：4，
“答案”：[
{
“文本/答案”：“否”，
“问题”：[
{
“问题”：“1.1.1”，
“级别”：2，
“id”：3，
“答案”：[]
}
]
},
{
“文本回答”：空，
“问题”：[
{
“问题”：“1.1.2”，
“级别”：2，
“id”：2，
“答案”：[
{
“文本/答案”：“SI”，
“问题”：[
{
“问题”：“1.1.2.1”，
"三级",，
“id”：1，
“答案”：[]
}
]
}
]
}
]
}
]
}
]
/*     [
{
“问题”：“1.1”，
"一级",，
“id”：4，
“儿童”：[
{
“问题”：“1.1.1”，
“文本/答案”：“否”，
“级别”：2，
“id”：3，
“儿童”：[]
},
{
“问题”：“1.1.2”，
“文本回答”：空，
“级别”：2，
“id”：2，
“儿童”：[
{     
“问题”：“1.1.2.1”，
“文本/答案”：“SI”，
"三级",，
“id”：1，
“儿童”：[]
}
]
}
]
}
]
*/
函数格式（d）{
如果（d.答案）{
d、 答案。forEach（（d）=>{
格式；
});
}
}
格式（数据）；
**注:**
为了更好地理解问题，我改变了前面的结构。
编写递归函数的方法是正确的

我认为你错在考虑把它“推”到一个数组或对象来存储数据

相反，应该发生的是递归函数返回格式化的数据，然后将该数据添加到新的json对象中，该对象被发送回调用堆栈


var数据={
“姓名”：“1.问题”，
“回答”：“是”，
“儿童”：[{
“名称”：“1.1问题”，
回答：“是”
},
{
“名称”：“1.2问题”，
“答案”：“否”，
“儿童”：[{
“名称”：“1.2.1问题”，
回答：“否”
}]
},
{
“名称”：“1.3问题”，
“回答”：“是”，
“儿童”：[{
“名称”：“1.3.1问题”，
“回答”：“是”，
“儿童”：[{
“名称”：“1.3.1.1问题”，
回答：“是”
}]
}]
}
]
}
函数格式（d）{
如果（d.儿童）{
//如果有孩子，你会更深入地重复
//使用Array.prototype.map函数对每个子项进行_变换。
const formattedChildren=d.children.map（v=>{
返回格式（v）；
});
//注意，我在这里返回一个新对象，以及
//已转换数据的聚合
返回{
数据：“新格式化的父节点数据在此显示”，
儿童：格式化儿童
};
}否则{//\u总是检查“是否为叶节点”。
//如果是叶节点，只需格式化即可。
//注意，我在这里返回一个新对象
返回{
数据：“新格式化的叶节点数据在此显示”
};
}
}
console.log（格式（数据））这里有一种通过递归的方法。我已经对代码进行了注释，以逐行解释到底发生了什么


function\u流程（项目）{
让result=item//我们定义一个item->result的副本
//这是重命名字段“answers”（如果找到）
如果（项目答案）{
result.children=item.answers.map（_process）//分别处理每个项目
删除结果。答案
}
//如果存在问题字段，则提取数组中的第一项并将属性与结果合并
若有（项目问题）{
结果={
…结果，
…_process（item.questions[0]）//在合并项目之前也尝试处理该项目（以检查是否存在嵌套的'questions'或'answers'字段）
}
删除结果。问题//删除问题字段
}
返回结果
}
功能流程（数据）{
return data.map（_process）//启动顶级对象的递归
}
//要测试的样本数据
常数数据=[{
“问题”：“1.1”，
"一级",，
“id”：4，
“答案”：[{
“文本/答案”：“否”，
“问题”：[{
“问题”：“1.1.1”，
“级别”：2，
“id”：3，
“答案”：[]
}]
},
{
“文本回答”：空，
“问题”：[{
“问题”：“1.1.2”，
“级别”：2，
“id”：2，
“答案”：[{
“文本/答案”：“SI”，
“问题”：[{
“问题”：“1.1.2.1”，
"三级",，
“id”：1，
“答案”：[]
}]
}]
}]
}
]
}]
常量结果=过程（数据）
console.log（JSON.stringify（result，null，2））
它适合我：


//这是您的JSON
var json=[{
“问题”：“1.1”，
"一级",，
“id”：4，
“答案”：[{
“文本/答案”：“否”，
“问题”：[{
“问题”：“1.1.1”，
“级别”：2，
“id”：3，
“答案”：[]
}]
},
{