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

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

javascript

Javascript 如何有效地确定闭包的深度,javascript,closures,Javascript,Closures,在闭包方面，如果只考虑返回另一个函数的函数，如以下示例所示。我们如何在运行时以编程方式确定此闭包的深度假设此函数的深度为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 } }

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

假设此函数的深度为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

正确地确定了

的深度，即3但是，在一些实际情况下，例如闭包将函数作为参数并调用它，我的函数
depth
无法处理。

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

*我的问题：有没有办法确定我的收尾深度更有效？特别是在上面提到的某些情况下（闭包将函数作为参数并调用它）。最受欢迎的是能够动态处理闭包的通用方法，闭包可以将某些函数作为参数，也可以不作为参数

p.S.让我把范围缩小如下

只考虑纯嵌套函数
嵌套函数的每一层总是返回相同的类型
函数的深度是恒定的
两个嵌套函数都不是递归函数

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

Reflector

Reflector

fh

//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;
}

else{return function H（b）{return function J（c）{return 1；}}}

Reflector