1.什么是尾递归？

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

我们知道递归非常耗费内存，因为需要同时保存成千上百个调用帧，很容易发生“栈溢出”错误（stack overflow）。

但对于尾递归来说，由于只存在一个调用帧，所以永远不会发生“栈溢出”错误。

一个阶乘函数，计算n的阶乘，最多需要保存n个调用记录，复杂度 O(n) 。

function factorial(n) {  if (n === 1) return 1;  return n * factorial(n - 1);}factorial(5) // 120

如果改写成尾递归，只保留一个调用记录，复杂度 O(1) 。

function factorial(n, total) {  if (n === 1) return total;  return factorial(n - 1, n * total);}factorial(5, 1) // 120

非尾递归的 Fibonacci 数列实现

function Fibonacci (n) {  if ( n <= 1 ) {return 1};  return Fibonacci(n - 1) + Fibonacci(n - 2);}Fibonacci(10) // 89Fibonacci(100) // 堆栈溢出Fibonacci(500) // 堆栈溢出

尾递归优化过的 Fibonacci 数列实现如下。

function Fibonacci2 (n , ac1 = 1 , ac2 = 1) {  if( n <= 1 ) {return ac2};  return Fibonacci2 (n - 1, ac2, ac1 + ac2);}Fibonacci2(100) // 573147844013817200000Fibonacci2(1000) // 7.0330367711422765e+208Fibonacci2(10000) // Infinity

“尾调用优化”对递归操作意义重大，所以一些函数式编程语言将其写入了语言规格。ES6 是如此，第一次明确规定，

所有 ECMAScript 的实现，都必须部署“尾调用优化”。这就是说，ES6 中只要使用尾递归，就不会发生栈溢出，相对节省内存。

尾递归的实现，往往需要改写递归函数，确保最后一步只调用自身。做到这一点的方法，就是把所有用到的内部变量改写成函数的参数。

比如上面的例子，阶乘函数 factorial 需要用到一个中间变量total，那就把这个中间变量改写成函数的参数。这样做的缺点就是不太直观，

第一眼很难看出来，为什么计算5的阶乘，需要传入两个参数5和1？两个方法可以解决这个问题。方法一是在尾递归函数之外，再提供一个正常形式的函数。

function tailFactorial(n, total) {  if (n === 1) return total;  return tailFactorial(n - 1, n * total);}function factorial(n) {  return tailFactorial(n, 1);}factorial(5) // 120

函数式编程有一个概念，叫做柯里化（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);factorial(5) // 120

上面代码通过柯里化，将尾递归函数tailFactorial变为只接受一个参数的factorial。

第二种方法就简单多了，就是采用 ES6 的函数默认值。

function factorial(n, total = 1) {  if (n === 1) return total;  return factorial(n - 1, n * total);}factorial(5) // 120

上面代码中，参数total有默认值1，所以调用时不用提供这个值。

总结一下，递归本质上是一种循环操作。纯粹的函数式编程语言没有循环操作命令，所有的循环都用递归实现，

这就是为什么尾递归对这些语言极其重要。对于其他支持“尾调用优化”的语言（比如 Lua，ES6），

只需要知道循环可以用递归代替，而一旦使用递归，就最好使用尾递归。

尾递归优化只在严格模式下生效，那么正常模式下，或者那些不支持该功能的环境中，有没有办法也使用尾递归优化呢？

回答是可以的，就是自己实现尾递归优化。它的原理非常简单。尾递归之所以需要优化，原因是调用栈太多，造成溢出，

那么只要减少调用栈，就不会溢出。怎么做可以减少调用栈呢？就是采用“循环”换掉“递归”。

蹦床函数（trampoline）可以将递归执行转为循环执行。

function trampoline(f) {  while (f && f instanceof Function) {    f = f();  }  return f;}

下面是一个正常的递归函数。

function sum(x, y) {  if (y > 0) {    return sum(x + 1, y - 1);  } else {    return x;  }}sum(1, 100000)// Uncaught RangeError: Maximum call stack size exceeded(…)

然后，要做的就是将原来的递归函数，改写为每一步返回另一个函数。

function sum(x, y) {  if (y > 0) {    return sum.bind(null, x + 1, y - 1);  } else {    return x;  }}

上面代码中，sum函数的每次执行，都会返回自身的另一个版本。现在，使用蹦床函数执行sum，就不会发生调用栈溢出。

trampoline(sum(1, 100000))// 100001

蹦床函数并不是真正的尾递归优化，下面的实现才是。

function tco(f) {  var value;  var active = false;  var accumulated = [];  return function accumulator() {    accumulated.push(arguments);    if (!active) {      active = true;      while (accumulated.length) {        value = f.apply(this, accumulated.shift());      }      active = false;      return value;    }  };}var sum = tco(function(x, y) {  if (y > 0) {    return sum(x + 1, y - 1)  }  else {    return x  }});sum(1, 100000)// 100001

本文借鉴和照抄自

关于尾递归这块我掌握的并不好