如何有效地确定闭包的深度

Question

就闭包而言，如果只考虑 返回另一个函数的函数，如下例所示。我们如何在运行时以编程方式确定此闭包的深度？

假设这个函数F的深度为2：

function F(a){ // 1
    return function G(b){ // 2
        return 'something';
    }
}

这个函数'H'的深度是3。

function H(a){ // 1
   return function(b){ //2
      return function(c){} //3
   }
}

到目前为止，我已经编写了一些简单的脚本来确定闭包的深度，方法是迭代检查函数的返回类型，直到它返回除函数之外的其他类型。 但我的脚本仅适用于每个嵌套函数不需要参数的情况。见以下代码：

function F(){
    return function(){
        return function(){
            return 1;
        }
   }
}

function depth(f){
    var n = 1;
    var ret = f();
    while (typeof(ret)=='function'){
        ret = ret(); 
        n++;
    }
    return n; 
}

上面的简单函数 depth 正确地确定了 F 的深度为 3。但是，在某些实际情况下，例如以函数为参数并调用它的闭包，我的函数 depth无法处理。

function F2(a,f){
    return function(g){
        return f(a) + g(a); // This will break my depth function
   }
}

*我的问题：有什么方法可以更有效地确定我的闭包深度吗？尤其是在上面提到的某些情况下（将函数作为参数并调用的闭包它）。可以动态处理可能会或可能不会将某些函数作为参数的闭包的通用方法将不胜感激。

P.S.让我缩小范围如下。

• 只考虑纯嵌套函数。
• 每一层嵌套函数总是返回相同的类型。
• 函数的深度是恒定的。
• 没有一个嵌套函数是递归的。

Answer 1

这更像是一个评论而不是一个答案，但最好在这里格式化。

除非您提供一组所有必需的参数，否则这不是一个可解决的问题。
考虑计算以下的“深度”：

function F(a) {
    if (a) {
        return function G(b) {
            return 0;
        }
    } else {
        return 1;
    }
}

Answer 2

您也许可以更改所有函数，以便它们也能够在没有参数的情况下运行，出于您的反思目的？
由于在深度计算期间，函数调用不应进行任何其他有用的计算或无论如何都有任何副作用。它们应该只返回一个函数或一个非函数值。
既然你说：“每一层嵌套函数总是返回相同的类型。 函数的深度是恒定的。”在遇到空参数列表时返回相应类型的虚拟响应的决定应该很简单。

Answer 3

这是另一种方法。这通过观察代码的行为方式在运行时起作用。
我的函数Reflector 是这种情况下的特殊酱汁。
请参阅https://jsfiddle.net/rffv34oz/8/ 以运行示例。

函数Reflector 做了四件事：
1。它通过返回钩子而不是原始函数来“检测”带有钩子 (fh) 的函数。效果是在调用该检测函数之前调用钩子。
2。当调用检测函数时，它会转发调用 - 它调用原始函数。并准备好捕获函数结果。
3。当函数返回时，它会检查结果。如果结果也是一个函数，它存储新的最大深度。
4。另外，当返回的结果是一个函数时，钩子也会检测返回的函数，因此步骤（1）再次应用于新的返回函数。

//Your function You want to USE and REFLECT on too.
function F(){ 
    //return 3;
    return function(){
        //return 2;
        return function(){
            return 1;
        }
   }
}

//Your function You want to USE and REFLECT on too.
function H(a){ // 1
    return function(b){ //2
        return function(c){ //3
            return a + b + c;   
        }
   }    
}

//this function is the machinery that knows how to USE the functions You want to measure. 
//But this function only USES them, but does no reflection.
function BlackboxF(f) { 

    var r1 = f();
    if (typeof r1 == "function")
    {
        var r2 = r1();
        if (typeof r2 == "function")
        {
            var r3 = r2();  

            return r3;
        }
        else 
        {
            return r2;   
        }
    }
    else 
    {
         return r1;   
    }

}

//this function is the machinery that knows how to USE the functions You want to measure. 
//But this function only USES them, but does no reflection.
function BlackboxH(f) { 

    var r1 = f(1);
    var r2 = r1(2);
    var r3 = r2(4);
    return r3;

}

var maxdepth = 1;

//This is the special agent for reflecting code as it runs
function Reflector(f, depth) { 

    if (!depth)
        depth = 1;

    //1. It "instruments" a function with a hook (`fh`) by returning the hook 
    //instead of the original function. The effect is that the hook is called 
    //before that instrumented function is called.
    var fh = function()     
    {
        //2. When the instrumented function is called, it forwards the call - it calls 
        //the original function. And remains ready for capturing the function result.
        var r = f.apply(this, arguments);    

        //3. When the function returns, it inspects the result. 
        //If the result is also a function, it stores new maximum depth.
        if (typeof r == "function")
        {
            maxdepth = Math.max(maxdepth, depth + 1);

            //4. Also, when the returned result was a function, the hook also 
            //instruments the returned function, so that step (1) is again applied 
            //for the new returned function.
            return Reflector(r, depth + 1);        
        }
        else 
        {
            return r;
        }
    };

    return fh;
}

if (false) //The simple case with no arguments
{
    var F2 = Reflector(F);
    var RF = BlackboxF(F2);

    document.getElementById("result").textContent = "Result: " + RF;
    document.getElementById("depth").textContent = "Depth: " + maxdepth;
}
else //A more complicated case with arguments
{
    var H2 = Reflector(H);
    var RH = BlackboxH(H2);

    document.getElementById("result").textContent = "Result: " + RH;
    document.getElementById("depth").textContent = "Depth: " + maxdepth;
}