Introduction

Tail recursion means the recursive call is the final action in the function, so in theory the runtime could reuse the current stack frame instead of creating a new one. In JavaScript, however, you should not rely on tail recursion optimization as a portable performance feature. Even if a function is written in tail-recursive form, common JavaScript environments may still grow the call stack.

What Tail Recursion Looks Like

This factorial function is recursive, but not tail-recursive, because it still multiplies after the recursive call returns:

1function factorial(n) {
2  if (n <= 1) {
3    return 1;
4  }
5
6  return n * factorial(n - 1);
7}

A tail-recursive version carries the running result in an accumulator:

1function factorialTail(n, acc = 1) {
2  if (n <= 1) {
3    return acc;
4  }
5
6  return factorialTail(n - 1, acc * n);
7}

In a language with guaranteed tail call optimization, the second version can run with constant stack space. That is the whole appeal.

Why JavaScript Is Different in Practice

JavaScript developers often hear that proper tail calls were part of the ECMAScript standard. That detail is real, but it does not translate into a practical guarantee across the environments people actually run.

The important engineering rule is this: if deep recursion must be safe, do not assume the JavaScript engine will optimize it away.

That means this can still fail for large input sizes:

1function sumTail(n, acc = 0) {
2  if (n === 0) {
3    return acc;
4  }
5
6  return sumTail(n - 1, acc + n);
7}
8
9console.log(sumTail(100000));

Even though the function is tail-recursive, it may still hit RangeError: Maximum call stack size exceeded.

Prefer Iteration for Production Code

If the problem can be expressed as a loop, a loop is usually the safest and clearest JavaScript solution.

1function sumIterative(n) {
2  let acc = 0;
3
4  while (n > 0) {
5    acc += n;
6    n -= 1;
7  }
8
9  return acc;
10}

This version does not depend on engine-specific optimization behavior and is generally what you should ship when recursion depth might be large.

The same rewrite works for many recursive tasks:

• accumulate results in a local variable
• use while or for
• manage your own stack if the original problem is tree-shaped or graph-shaped

Trampolines as a Recursion-Friendly Alternative

If you like recursive structure for readability, a trampoline is one workaround. Instead of making a real recursive call, each step returns a function representing the next step. A loop then repeatedly invokes those functions.

1function trampoline(fn) {
2  while (typeof fn === "function") {
3    fn = fn();
4  }
5
6  return fn;
7}
8
9function sumSafe(n, acc = 0) {
10  if (n === 0) {
11    return acc;
12  }
13
14  return () => sumSafe(n - 1, acc + n);
15}
16
17console.log(trampoline(() => sumSafe(100000)));

This avoids stack growth because the recursive structure is converted into an explicit loop at runtime. It is more verbose than a simple loop, but it keeps the recursive style if that matters for the algorithm.

Optimization vs Readability

Tail recursion is often discussed as an optimization technique, but in JavaScript the bigger decision is usually readability versus portability.

If a recursive function is shallow and naturally expresses the problem, using recursion can still be fine. Tree walking, parser code, and some divide-and-conquer algorithms can stay readable that way.

If the recursion depth depends on user input or large datasets, rewrite it. At that point the stack risk is more important than the elegance of the recursive form.

Common Pitfalls

The biggest pitfall is assuming “tail-recursive” automatically means “stack-safe.” In JavaScript, that is not a reliable assumption.

Another common mistake is believing that adding an accumulator parameter alone solves the problem. It only changes the shape of the function. Whether the runtime eliminates stack frames is a separate question.

Developers also sometimes benchmark tiny recursive examples and conclude that recursion is fine everywhere. The real problem appears at larger depths, where stack growth and engine limits become visible.

Finally, be careful with mutually recursive functions. Even in environments that might optimize some tail calls, cross-function recursion is usually not something you should trust for unbounded depth.

Summary

• Tail recursion means the recursive call is the final operation in the function.
• In JavaScript, do not depend on tail call optimization for portability or stack safety.
• Rewrite deep recursion as iteration when large input sizes are possible.
• A trampoline can preserve recursive structure without using the call stack.
• Treat tail-recursive style as a code shape, not as a guaranteed optimization.