ES6函数尾调用，尾递归及优化深入理解

本文已同步到：个人博客地址

什么是尾调用

尾调用（Tail Call）就是指某个函数的最后一步是返回调用另一个函数的执行结果。如下

一下情形都不是尾调用

上面代码中:
情况一是调用函数g之后，还有赋值操作，所以不属于尾调用，即使语义完全一样。
情况二也属于调用后还有操作，即使写在一行内。
情况三等同于右面的代码。

尾调用不一定出现在函数尾部，只要是最后一步操作即可。上面代码中，函数m和n都属于尾调用，因为它们都是函数f的最后一步操作。

函数尾调用的优化

尾调用之所以与其他调用不同，就在于它的特殊的调用位置。

我们知道，函数调用会在内存形成一个“调用记录”，又称“调用帧”（call frame），保存调用位置和内部变量等信息。

• 如果在函数A的内部调用函数B，那么在A的调用帧上方，还会形成一个B的调用帧。
• 等到B运行结束，将结果返回到A，B的调用帧才会消失。
• 如果函数B内部还调用函数C，那就还有一个C的调用帧，以此类推。 所有的调用帧，就形成一个“调用栈”（call stack）

尾调用由于是函数的最后一步操作，所以不需要保留外层函数的调用帧，因为调用位置、内部变量等信息都不会再用到了，只要直接用内层函数的调用帧，取代外层函数的调用帧就可以了。

上面的函数不会进行尾调用优化，因为内层函数inner用到了外层函数addOne的内部变量one。

注意，只有不再用到外层函数的内部变量，内层函数的调用帧才会取代外层函数的调用帧，否则就无法进行“尾调用优化”。

尾递归

函数调用自身，称为递归。如果尾调用自身，就称为尾递归。

递归非常耗费内存，因为需要同时保存成千上百个调用帧，很容易发生“栈溢出”错误（stack overflow）。但对于尾递归来说，由于只存在一个调用帧，所以永远不会发生“栈溢出”错误

总结一下，递归本质上是一种循环操作。纯粹的函数式编程语言没有循环操作命令，所有的循环都用递归实现，这就是为什么尾递归对这些语言极其重要。对于其他支持“尾调用优化”的语言（比如 Lua，ES6），只需要知道循环可以用递归代替，而一旦使用递归，就最好使用尾递归。

函数尾调用的开启条件

ES6 的尾调用优化只在严格模式下开启，正常模式是无效的。
这是因为在正常模式下，函数内部有两个变量，可以跟踪函数的调用栈
func.arguments：返回调用时函数的参数。
func.caller：返回调用当前函数的那个函数。
尾调用优化发生时，函数的调用栈会改写，因此上面两个变量就会失真。严格模式禁用这两个变量，所以尾调用模式仅在严格模式下生效。

怎么解决上述问题了，如下用了while循环

它的原理非常简单。尾递归之所以需要优化，原因是调用栈太多，造成溢出，那么只要减少调用栈，就不会溢出。就是采用“循环”换掉“递归”。

尾调用的最优优化

function tco(f){
    var value;
    var active = false;
    var accumulated = []  //闭包存储每次传输进来的数据

    return function accumulator(){
        accumulated.push(arguments)//把每次传进来的参数数组预存到这个数组里面
        console.log(accumulated);

        debugger
        if(!active){
            active = true
            console.log(accumulated.length);
            while(accumulated.length){
                value = f.apply(this,accumulated.shift())
                console.log(value);
            }
            
            return  value
        }


    }
}


var sum = tco(function(x,y){
    if(y>0){
        return sum(x+1,y-1)
    }else{
        return x
    }
})


sum(1,10)

代码中，tco函数是尾递归优化的实现，它的奥妙就在于状态变量active。默认情况下，这个变量是不激活的。一旦进入尾递归优化的过程，这个变量就激活了。然后，每一轮递归sum返回的都是undefined，所以就避免了递归执行；而accumulated数组存放每一轮sum执行的参数，总是有值的，这就保证了accumulator函数内部的while循环总是会执行。这样就很巧妙地将“递归”改成了“循环”，而后一轮的参数会取代前一轮的参数，保证了调用栈只有一层。