Javascript 根据条件检查遍历每个对象数组

我有一个场景，需要遍历对象中的每个父/子数组

每个祖父母可以有多个父母，以同样的方式，每个父母可以有多个孩子，每个孩子可以有多个子孩子，等等

我需要在迭代时检查类型是“parent”还是“child”，然后将name属性按预期输出中提到的方式推送到数组中

输入对象：

 var inputObject = {
  "id": 1,
  "name": "Grand Parent 1",
  "type": "GrandParent",
  "childType": [
   {
     "id": 2,
     "type": "Parent",
     "childType": [
    {
      "id": 3,
      "type": "Child",
      "childType": [],
      "name": "Child 11"
    },
    {
      "id": 4,
      "type": "Child",
      "childType": [],
      "name": "Child 12"
    }
  ],
  "name": "Parent 1"
},
{
  "id": 5,
  "type": "Parent",
  "childType": [
    {
      "id": 6,
      "type": "Child",
      "childType": [],
      "name": "Child 21"
    }
  ],
  "name": "Parent 2"
},
{
  "id": 7,
  "type": "Parent",
  "childType": [
    {
      "id": 8,
      "type": "Child",
      "childType": [],
      "name": "Child 31"
    }
  ],
  "name": "Parent 3"
}
 ]
 }

已尝试的代码：

 function handleData({childType, ...rest}){
  const res = [];
  res.push(rest.name);
  if(childType){
  if(rest.type == "Child")
    res.push(...handleData(childType));
  }
  return res;
}

const res = handleData(inputObject);

预期产出：

If type selected is "Parent"
["Parent 1", "Parent 2, Parent 3"]

if type selected is "Child"
["Child 11", "Child 12", "Child 21", "Child 31"]

---

您可以使用递归来实现这一点

步骤：

• 创建一个包装函数，在其中声明结果数组
• 在它的内部，使包装器函数创建一个递归调用的函数
• 检查类型是否与给定类型匹配将对象的

  名称添加到结果

• 然后检查其

  子类型中是否存在元素。如果是，则对每个元素调用函数

var inputObject={“id”：1，“name”：“Grand Parent 1”，“type”：“祖父母”，“childType”：[{“id”：2，“type”：“Parent”，“childType”：[{“id”：3，“type”：“Child”，“childType”：[]，“name”：“Child 11”}，{“id”：4，“type”：“Child”，“childType”：[]，“name”：“Child 12”}，“name”：“Parent 1”}，{“id”：5，“type”：“Parent”，“childType”：“childType”：“id”：6，“type”：“Child”，“childType”：[]，“name”：“Child 21”}]，“name”：“Parent 2”}，{“id”：7，“type”：“Parent”，“childType”：[{“id”：8，“type”：“Child”，“childType”：[]，“name”：“Child 31”}]，“name”：“Parent 3”}]
功能句柄数据（obj，类型）{
设res=[]；
函数递归（obj）{
if（type==obj.type）res.push（obj.name）；
if（对象子类型长度）{
forEach（a=>recursive（a））；
}
}
递归（obj）
返回res；
}
日志（handleData（inputObject，“子”））
log（handleData（inputObject，“Parent”）

您可以使用以下递归函数：

const obj={id:1，名称：“祖父母1”，类型：“祖父母”，儿童类型：[{id:2，类型：“父母”，儿童类型：[{id:3，类型：“孩子”，儿童类型：[]，名称：“孩子11”}，{id:4，类型：“孩子”，儿童类型：[]，名称：“孩子12”}，{id:5，类型：“父母”，儿童类型：[{id:6，类型：“孩子”，儿童类型：[]，名称：“父母2”}，{id:7，类型：“父母”，childType:[{id:8，type:“Child”，childType:[]，name:“Child 31”}，name:“Parent 3”}]}；
const get=（o，t）=>o.type==t？[o.name]：o.childType.flatMap（c=>get（c，t））；
log（get（obj，'祖父母'）；
log（get（obj，'Parent'）；
log（get（obj，'Child'）递归非常优雅，但您可以使用es6来实现，如果对象子类型非常大，则递归可能不适用（堆栈溢出），这里有一个使用reduce的解决方案

function getType({childType}, type) {
  return childType.reduce( (acc, {type: objectType, name}) => { 
   if (objectType === type){
     acc.push(name)
   }
   return acc
  }, [])
}

您可以使用递归来解决这个问题。你可以这样试试


var inputObject={
“id”：1，
“姓名”：“祖父母1”，
“类型”：“祖父母”，
“儿童类型”：[
{
“id”：2，
“类型”：“父级”，
“儿童类型”：[
{
“id”：3，
“类型”：“子项”，
“儿童类型”：[]，
“姓名”：“儿童11”
},
{
“id”：4，
“类型”：“子项”，
“儿童类型”：[]，
“姓名”：“子女12”
}
],
“名称”：“父级1”
},
{
“id”：5，
“类型”：“父级”，
“儿童类型”：[
{
“id”：6，
“类型”：“子项”，
“儿童类型”：[]，
“姓名”：“儿童21”
}
],
“名称”：“父级2”
},
{
“id”：7，
“类型”：“父级”，
“儿童类型”：[
{
“id”：8，
“类型”：“子项”，
“儿童类型”：[]，
“姓名”：“儿童31”
}
],
“名称”：“父级3”
}
]
};
var结果值=[]；
函数getResult（inputObject、propertyName、propertyValue）{
for（inputObject中的var objectProperty）{
if（objectProperty==propertyName&&inputObject[objectProperty]==propertyValue）{
push（inputObject['name']）；
console.log（结果值）；
}否则{
如果（objectProperty=='childType'）{
inputObject[objectProperty].forEach（函数（元素）{
getResult（元素、propertyName、propertyValue）
});
}
}
}
//console.log（结果值）；
}
getResult（inputObject，'类型'，'祖父母'）；
getResult（inputObject，'type'，'Parent'）；
getResult（inputObject，'type'，'Child'）好方法交配+ 1。@ HasigMeGHARAJ考虑接受你最满意的答案。