Question

我有这个递归函数，它意味着递归地遍历容器对象的级别并检查它们是否是打开的。同时我需要返回一个计数器，该计数器针对每个级别的嵌套容器递增，该容器具有未打开的容器。

所以容器结构可能看起来像这样（但是函数需要是动态的）：

container {
    open: true,
    containers: [
        {
            open: false,
            containers: [

                    {
                        open: false,
                        containers: [

                        ]
                    },
                    {
                        open: false,
                        containers: [

                        ]
                    },
                    {
                        open: false,
                        containers: [

                        ]
                    },
            ]
        },
        {
            open: true,
            containers: [

                    {
                        open: false,
                        containers: [

                        ]
                    },
                    {
                        open: true,
                        containers: [

                        ]
                    },
                    {
                        open: false,
                        containers: [

                        ]
                    },
            ]
        }
    ]
}

目前我已经编写了一个函数来遍历4级容器来进行检查，但是我希望能够让它继续运行。

function checkChildren(container) {
      var x = 0;
      if(closedCheck(container)) {
        x++;
        if(loopCheck(closedCheck(container), closedCheck)) {
          x++;
          if(loopCheck(loopCheck(closedCheck(container), closedCheck), closedCheck)) {
            x++;
            if(loopCheck(loopCheck(loopCheck(closedCheck(container), closedCheck), closedCheck), closedCheck)) {
              x++;
            }
          }
        }
      }

      return x;

      function closedCheck(container) {
        if(typeof container.containers !== 'undefined') {
          return container.containers.filter(function(val) {
            return val.open === false;
          })
        } else return false;
      }

      function loopCheck(containers, callback) {
        return containers.filter(callback);
      }
    }

t遍历每个级别的容器。例如，第一级是根容器.containers。第二级包括第一级中每个容器中的“容器”数组。对于具有“打开=== false”的容器的每个级别，计数器递增。在这种情况下，计数器是根据迭代或条件增加或减少的数字。预期输出是表示该计数器的数字。所以，如果我要为根容器调用此函数。结果将是2，因为在那里有两个级别是一个封闭的容器。

有没有人知道如何简化并使其更具动态性？

谢谢！

Answer 1

或许这样的事情：

function findDeepest(obj,lvl) {
    if (!obj) {
        return 0;
    }
    if (!obj.open) {
        return lvl;
    }
    if (!obj.containers || !obj.containers.length) {
        return 0;
    }
    var subTrees = obj.containers.map(function (item) {
        return findDeepest(item,lvl+1);
    });
    return Math.max.apply(Math, subTrees);
}

console.log(findDeepest(container ,0));

我们的想法是从顶部（0级）开始，如果该对象是开放的，我们将其所有的孩子都放下，直到我们找到封闭的容器，然后我们选择那些最大（即最深）并返回它

简化递归函数（并使其更具功能性）

1 个答案: