尾调用之所以与其他调用不同，就在于它的特殊调用位置
一般来说，函数调用会在内存形成一个“调用记录”，又称“调用帧”(call frame)，保存调用位置和内部变量等信息。如果在函数A内部调用函数B，那么在A的调用帧上方，还会形成一个B的调用帧。等到B运行结束，将结果返回到A，B的调用帧才会消失。如果还是内部还调用函数C，那就还有一个C的调用帧，以此类推。所有的调用帧，就会形成一个“调用栈”(call stack)
尾调用由于是函数的最后一步操作，所以不需要保留外层函数的调用帧，因为调用位置，内部变量等信息都不会再用到，只要直接用内层函数的调用帧，取代外层函数的调用帧就可以了
function f() {
let m = 1;
let n = 2;
return g(m + n)
}
//等同于
function f() {
return g(3);
}
f()
//等同于
g(3)
上面代码中，如果函数g不是尾调用，函数f就需要保存内部变量m和n的值，但是由于调用g之后，函数f就结束了，所以执行到最后一步，完全可以删除f(x)的调用帧，只保留g(3)的调用帧
这就叫做“尾调用优化”（Tail call optimization），即只保留内层函数的调用帧，如果所有函数都是尾调用，那么完全可以做到每次执行时，调用帧只有一项，这将大大节省内存，这就是“尾调用优化”的意义
只有不再用到外层函数的内部变量，内层函数的调用帧才会取代外层函数的调用帧，否则无法进行“尾调用优化”
function addOne(a) {
let one = 1;
function inner(b) {
return b + one
}
return inner(a)
}
上面的函数不会进行尾调用优化，因为内层函数inner用到了外层函数addOne的内部变量one
尾递归
函数调用自身，称为递归。如果尾调用自身就称为尾递归
递归非常耗费内存，因为需要同时保存成千上百个调用帧，很容易发生“栈溢出”错误（stack overflow）。但是对于尾递归来说，由于只存在一个调用帧。所以永远不会发生“栈溢出”错误
举个🌰
function factorial(n) {
if (n === 1) return 1;
return n * factorial(n - 1)
}
console.log(factorial(5)); // 120
console.log(factorial(4)); // 24
上面代码是一个阶乘函数，计算n的阶乘，最多需要保存n个调用记录。如果改写成尾递归，只保留一个调用记录。
function factorial(n, total) {
if (n === 1) return total;
return factorial(n - 1, n * total);
};
console.log(factorial(5, 1)); // 120
console.log(factorial(4, 1)); // 24
还有一个比较著名的例子，就是计算Fibonacci数列（斐波那契数列），也能充分说明尾递归优化的重要性
function Fibonacci(n) {
if (n <= 1) { return 1 };
return Fibonacci(n - 1) + Fibonacci(n - 2)
}
console.log(Fibonacci(10)); //89
console.log(Fibonacci(100)); //堆栈溢出
尾调用优化过后的Fibonacci数列实现如下
function Fibonacci(n, ac1 = 1, ac2 = 1) {
if (n <= 1) { return ac2 };
return Fibonacci(n - 1, ac2, ac1 + ac2);
}
console.log(Fibonacci(10)); //89
console.log(Fibonacci(30)); //1346269
console.log(Fibonacci(100)); //10946
“尾调用优化”对递归操作意义重大，所以一些函数式编程语言将其写入了语言规格。第一次明确规定，所有ECMAScript的实现，都必须部署“尾调用优化”。就是说，ES6中只要使用尾递归，就不会发生栈溢出，相对节省内存
递归函数改写
尾递归的实现，往往需要改写递归函数，确保最后一步只调用自身。做到这一点的方法就是把所有用到的内部变量改写成函数的参数，比如上面的例子。阶乘函数factorial需要用到一个中间变量total，那么就把这个中间变量改写成函数的参数，这样做的缺点就是不太只管，第一眼很难看出来，为什么计算5的阶乘，需要传入两个参数5和1.
function tailFactorial(n, total) {
if (n === 1) return total;
console.log(n - 1, n * total);
/**
* 4 5
* 3 20
* 2 60
* 1 120
*/
return tailFactorial(n - 1, n * total)
}
function factorial(n) {
return tailFactorial(n, 1)
}
factorial(5)
上面代码通过一个正常形式的阶乘函数factorial，调用尾递归函数tailFactorial，看起来就正常多了
函数式编程有一个概念，叫做柯里化（currying），意思是将多参数的函数转换成单参数的形式。这里也可以使用柯里化
function currying(fn, n) {
return function(m) {
return fn.call(this, m, n)
}
}
function tailFactorial(n, total) {
if (n === 1) return total;
return tailFactorial(n - 1, n * total)
}
const factorial = currying(tailFactorial, 1);
console.log(factorial(5));//120
上面函数通过柯里化，将尾递归函数tailFactorial变为只接收一个参数的factorial
第二种方法就简单多了，直接用ES6的函数默认值。
function factorial(n, total = 1) {
if (n === 1) return total;
return factorial(n - 1, n * total)
}
//上面方法中，参数total有默认值1，所以调用时不用提供这个值
console.log(factorial(5)); //120
递归本质上是一种循环操作。纯粹的函数式编程语言没有循环操作命令，所有的循环都用递归实现，这就是为什么尾递归对这些语言极其重要，对于其他支持“尾调用优化”的语言，只需要循环可以用递归代替，而一旦使用递归，最好就用尾递归
尾递归优化的实现
尾递归优化只有在严格模式下生效，在正常模式下，或者不支持该功能的语言环境中，需要自己实现尾调用优化。
原理是尾递归之所以需要优化，原因是调用栈太多，造成溢出。那么只要减少调用栈，就不会溢出。
采用“循环”替代“递归”
一个正常的递归函数：
function sum(x, y) {
if (y > 0) {
return sum(x + 1, y - 1)
} else {
return x
}
}
console.log(sum(1, 100000));
//RangeError: Maximum call stack size exceeded
上面这个sum是一个递归函数，参数x是需要累加的值，参数y控制递归次数，一旦sum递归100000次。就会报错，提示超出调用栈的最大次数
将递归执行转为循环执行
function trampoline(f) {
/**
* 接收一个函数f作为参数，只要f执行后返回一个函数就继续执行
* 这里是返回一个函数，然后执行该函数，而不是函数里面调用函数
* 这样就避免了递归执行，从而消除报错问题
* */
while (f && f instanceof Function) {
f = f();
}
return f;
}
//修改原来的sum函数，使得sum函数的每次执行，都会返回自身另一个版本
function sum(x, y) {
if (y > 0) {
return sum.bind(null, x + 1, y - 1)
} else {
return x
}
}
console.log(trampoline(sum(1, 100000))); //100001
但是上面的trampoline函数并不是真正的尾调用优化，下面实现才是
function tco(f) {
let value;
//默认情况下，这个状态变量active不激活（1），
let active = false;
let accumulated = [];
return function accumulator() {
//accumulated数组存放每一轮sum执行的参数（3）
accumulated.push(arguments);
if (!active) {
//一旦进入尾递归优化的过程，这个变量激活（2）
active = true;
while (accumulated.length) {
//每一轮递归，sum返回的都是undefined，避免了递归执行
//而accumulated数组存放的每一轮的sum执行的参数，总是有值的，保障了while循环总是会执行
value = f.apply(this, accumulated.shift());
//shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。
}
active = false;
return value;
}
}
}
let sum = tco((x, y) => {
if (y > 0) {
return sum(x + 1, y - 1)
} else {
return x
}
});
console.log(sum(1, 100000)); //100001
