一、定义
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
二、利弊
递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
三、优化
解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
尾递归的判断标准是函数运行【最后一步】是否调用自身，而不是是否在函数的【最后一行】调用自身。
//普通递归
function f(x) {
if (x === 1) return 1;
return 1 + f(x - 1);
}
//尾递归
function f(x) {
if (x === 1) return 1;
return f(x - 1)
}
// 阶乘
function factorial(n) {
if (n === 1) return n;
return n * factorial(n - 1);
}
// 阶乘改版
function factorial(n, total) {
if (n === 1) return total;
return factorial(n - 1, n * total)
}
var a = factorial(5,1)
console.log(a) // 120
尾递归优化
尾递归优化只在严格模式下生效，那么正常模式下，或者那些不支持该功能的环境中，有没有办法也使用尾递归优化呢？回答是可以的，就是自己实现尾递归优化。
它的原理非常简单。尾递归之所以需要优化，原因是调用栈太多，造成溢出，那么只要减少调用栈，就不会溢出。怎么做可以减少调用栈呢？就是采用“循环”换掉“递归”。
// 尾递归函数
function sum(x, y) {
if (y > 0) {
return sum(x + 1, y - 1)
} else {
return x;
}
}
// var b = sum(1, 1000000)//RangeError: Maximum call stack size exceeded
// console.log(b)
// 尾递归优化
// 蹦床函数（trampoline）可以将递归执行转为循环执行。
/**
* 下面就是蹦床函数的一个实现，它接受一个函数f作为参数。
* 只要f执行后返回一个函数，就继续执行。
* 注意，这里是返回一个函数，然后执行该函数，而不是函数里面调用函数，
* 这样就避免了递归执行，从而就消除了调用栈过大的问题。
* 然后，要做的就是将原来的递归函数，改写为每一步返回另一个函数。
* @param {*} f
*/
function trampoline(f) {
while (f && f instanceof Function) {
f = f();
}
return f;
}
/**
* @param {*} x:初始值
* @param {*} y:递归次数
* sum2函数的每次执行，都会返回自身的另一个版本
*/
// 改写sum
function sum2(x, y) {
if (y > 0) {
return sum2.bind(null, x + 1, y - 1);
} else {
return x;
}
}
var c = trampoline(sum2(1, 100000))
console.log(c) //100001
蹦床函数并不是真正的尾递归优化，下面的实现才是。
console.log("tcotcotco")
function tco(f) {
var value, active = false, accumulated = [];
return function accumulator() {
// console.log(arguments)
accumulated.push(arguments);
// console.log(accumulated[0])
if (!active) {
active = true;
while (accumulated.length) {
value = f.apply(this, accumulated.shift());
// value = f.call(this, ...accumulated.shift()); // 等价于上句
// console.log(value) // undefined
}
active = false;
return value;
}
}
}
var sum3 = tco(function(x, y) {
if (y > 0) {
return sum3(x + 1, y - 1)
} else {
return x;
}
});
var d = sum3(1,100000)
console.log(d)
上面代码中，tco函数是尾递归优化的实现，它的奥妙就在于状态变量active。默认情况下，这个变量是不激活的。一旦进入尾递归优化的过程，这个变量就激活了。然后，每一轮递归sum返回的都是undefined，所以就避免了递归执行；而accumulated数组存放每一轮sum执行的参数，总是有值的，这就保证了accumulator函数内部的while循环总是会执行。这样就很巧妙地将“递归”改成了“循环”，而后一轮的参数会取代前一轮的参数，保证了调用栈只有一层。
