Question

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

每个祖父母可以有多个父母，每个父母可以有多个孩子，每个孩子可以有多个子孩子，依此类推。

我需要在迭代时检查类型是“父”还是“子”，然后按预期输出中所述将name属性推入数组。

输入对象：

.orbit

尝试过的代码：

 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);

Answer 1

您可以使用flatMap()做一个递归函数：

const obj = {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"}]};

const get = (o, t) => o.type === t ? [o.name] : o.childType.flatMap(c => get(c, t));

console.log(get(obj, 'GrandParent'));
console.log(get(obj, 'Parent'));
console.log(get(obj, 'Child'));

Answer 2

您可以使用递归来实现。

步骤：

创建一个包装函数，在其中声明结果数组。
在其中使包装函数创建一个将被递归调用的函数
检查类型是否与给定类型匹配，将对象name添加到结果中
然后检查其childType中是否存在元素。如果是，则在每个元素上调用函数。

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(obj,type){
  let res = [];
  function recursive(obj){    
    if(type === obj.type) res.push(obj.name);
    if(obj.childType.length){
      obj.childType.forEach(a => recursive(a));
    }
  }
  recursive(obj)
  return res;
}

console.log(handleData(inputObject,"Child"))
console.log(handleData(inputObject,"Parent"))

Answer 3

递归很优雅，但是您可以使用es6来实现，如果对象childType非常大，则递归可能不适用（堆栈溢出），这是使用reduce的解决方案，

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

Answer 4

您可以使用递归解决此问题。您可以尝试这种方式！

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"
              }
                ]
            };
            
            
var resultValues = [];
    function getResult(inputObject, propertyName, propertyValue) {
        for (var objectProperty in inputObject) {
            if (objectProperty == propertyName && inputObject[objectProperty] == propertyValue) {
                resultValues.push(inputObject['name']);
                console.log(resultValues);
            } else {
                if (objectProperty == 'childType') {
                    inputObject[objectProperty].forEach(function (element) {
                        getResult(element, propertyName, propertyValue)
                    });
                }
            }
        }

        //console.log(resultValues);
    }

    getResult(inputObject, 'type', 'GrandParent');
    getResult(inputObject, 'type', 'Parent');
    getResult(inputObject, 'type', 'Child');

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

4 个答案:

步骤：