递归在函数式编程里是核心表达手段，它用自身调用自身的方式描述问题，让阶乘、斐波那契、树遍历等算法看起来更接近数学定义。但JavaScript中的递归有一个明显短板：只要输入规模稍微变大，控制台就会抛出RangeError: Maximum call stack size exceeded。这个问题不能靠增加超时或捕获异常来解决，因为根源在调用栈的物理容量上。想要在JS中继续使用递归，需要理解尾调用优化的工作机制，并掌握改写递归和绕过限制的方法。

调用栈如何限制递归深度

每调用一个函数，JS引擎就会创建一个执行上下文，其中包含局部变量、参数、this指向和返回位置，这些信息被压入调用栈。函数执行完毕后，对应上下文从栈顶弹出。递归本质上是在函数尚未返回时再次调用自身，于是栈中会同时存在多个未完成的帧。以阶乘为例：factorial(5)在等待factorial(4)的结果，factorial(4)又在等待factorial(3)，所以栈帧不断叠加。这个等待链条一长，就会触及环境的栈上限。

function factorial(n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}
console.log(factorial(5)); // 120
console.log(factorial(100000)); // RangeError: Maximum call stack size exceeded

从上面代码能看到，factorial(100000)根本执行不到实际计算阶段，调用栈就已经爆掉了。不同浏览器和Node.js的栈上限不同，通常在一万到几万帧之间，所以很多看似正常的递归在测试环境没暴露，上线后面对稍大数据集就崩溃。重要的是，这种失败不是逻辑错误，而是栈空间被顺序消耗的结果。

当前栈帧不能提前释放的原因在于，函数返回前还有乘法操作，必须等子调用返回后才能完成。这样的递归叫作非尾调用递归，它与尾调用优化能处理的情况有本质区别。

尾调用与尾递归的判定条件

尾调用指一个函数在最后一步调用另一个函数，并且把这个调用的返回值直接作为自己的返回值返回。所谓“最后一步”，不是说调用出现在函数体的最后一行，而是说该调用执行后当前函数不再做任何额外计算。看两个例子：

// 尾调用
function process() {
  return save(); // 直接返回save的结果
}
// 非尾调用
function process2() {
  return 1 + save(); // 还需执行加法
}

尾递归就是函数在尾部调用自身的特殊情况。之所以强调尾部，是因为引擎如果要做尾调用优化，只有当外层调用结束后不再需要任何局部状态时，才可以用新函数的上下文替换旧函数的上下文。这样栈深度不再随调用次数线性增长。在ES2015规范中，尾调用优化被纳入标准，但要求代码运行在严格模式下，因为严格模式禁用了函数的caller和arguments累赘属性，给运行时留出了复用栈帧的空间。

'use strict';
function tailCallExample(n) {
  if (n === 0) return 'done';
  return tailCallExample(n - 1); // 尾递归
}

不过规范是一回事，引擎支持是另一回事。目前只有少数引擎如Safari的JavaScriptCore对尾调用优化支持较好，V8和SpiderMonkey很长一段时间没有默认开启。因此，指望纯靠引擎TCO来处理大规模递归，在浏览器和Node.js环境里并不可靠。

将普通递归改写为尾递归

要让一个递归满足尾调用条件，常用的方法是为函数添加累积参数。累积参数负责把上一步的计算结果传给下一步，这样最后一步就不再需要返回后再计算。

先看阶乘。普通版本返回n * factorial(n - 1)，乘法在递归调用之后执行，所以不是尾调用。可以增加acc参数，把乘法提前完成：

'use strict';
function factorialTail(n, acc = 1) {
  if (n <= 1) return acc;
  return factorialTail(n - 1, n * acc);
}
console.log(factorialTail(5)); // 120

现在函数每次到达最后一行都只是返回factorialTail(...)的调用结果，没有附加计算。在支持TCO的引擎中，这个调用会复用当前栈帧，输入再大也不会造成栈溢出。但要注意，递归深度问题解决了，结果数值本身可能超出Number安全范围，这是另一个话题。

斐波那契数列的改写更能说明累积参数的价值。普通fib是典型指数复杂度，而且在n稍大时还容易栈溢出。尾递归版本使用两个参数同时保存前两项：

'use strict';
function fib(n) {
  if (n < 2) return n;
  return fib(n - 1) + fib(n - 2);
}
function fibTail(n, a = 0, b = 1) {
  if (n === 0) return a;
  if (n === 1) return b;
  return fibTail(n - 1, b, a + b);
}

尾递归版把加法和递推关系都放进了参数传递过程中，递归调用成为最终操作，并且时间复杂度降为线性。即便如此，在V8上直接调用fibTail(100000)仍可能因为缺少TCO而溢出，这时候就需要借助替代方案。

引擎不支持TCO时怎么办

既然多数JavaScript运行环境不提供稳定的尾调用优化，就需要用代码手段把栈消耗降下来。蹦床函数是一种常见思路：把递归调用包装成返回一个函数值，而不是直接进行真正的调用，然后用循环驱动它一层一层执行。

function trampoline(fn) {
  let result = fn;
  while (typeof result === 'function') {
    result = result();
  }
  return result;
}
function factorialTramp(n, acc = 1) {
  if (n <= 1) return acc;
  return () => factorialTramp(n - 1, n * acc);
}
console.log(trampoline(() => factorialTramp(100000)));

蹦床的原理是每次返回一个thunk函数，外层while循环调用它，相当于把调用栈的压力转移到了堆和循环上。虽然多了一层闭包分配，但避免了深层栈帧，n值很大时依然能执行完成。缺点是写法不够直观，每个递归分支都要记得返回箭头函数。

如果追求性能和可读性，更稳妥的替代方案是直接把递归逻辑改成循环。用循环模拟递归可以完全消除栈增长，而且JIT引擎对循环的优化非常成熟。比如阶乘可以这样写：

function factorialLoop(n) {
  let acc = 1;
  for (let i = 1; i <= n; i++) {
    acc *= i;
  }
  return acc;
}
console.log(factorialLoop(100000)); // Infinity，但不报错

循环写法不存在栈溢出风险，执行速度也更快。对于一些不能简单转换成循环的递归，比如树遍历，可以用显式栈数组模拟，不过这会增加代码复杂度。选择哪种方式需要在可读性、性能和安全性之间权衡。

实际项目中的最佳实践

在函数式JavaScript开发中，递归经常用来处理列表折叠、树结构遍历和组合子逻辑。与其遇到栈溢出后再补救，不如一开始就评估数据规模和运行环境。对于确定很小的递归深度，比如处理配置文件或小型树结构，普通递归足够清晰，不需要引入额外机制。对于可能达到数千层以上的递归，优先考虑尾递归加蹦床，或者直接改写为循环。若团队使用TypeScript，还可以用类型约束递归参数，配合栈保护逻辑。

另外需要纠正一个常见误解：尾调用优化并不是让递归变快，而是让递归不再占用额外的栈空间。它不会减少算法本身的复杂度，也不会改善单层调用里的计算开销。对斐波那契来说，即便有TCO，如果仍然用普通双递归写法，指数级的时间消耗照样会拖垮页面。把递归改成尾递归、再换成循环或记忆化，往往比单纯开启TCO更实际。

测试时也建议在不同引擎中验证，不要只在某一浏览器上通过就认定代码可靠。可以写一个小工具，在Node.js里用try-catch捕获RangeError，或者用环境变量调整栈大小。核心逻辑最好保持纯函数，便于在不同执行策略间切换。