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

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 遍历容器的每一层。例如，第一级是根 container.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 级）开始，如果该对象是打开的，那么我们会向下遍历所有子对象，直到找到封闭的容器，然后我们选择其中的最大值（即最深）并返回它.