Recursion in JavaScript: Base Cases, Stack, and Optimization

Recursion is a technique in programming where a function calls itself to solve a problem.

Each recursive call works with a smaller part of the original problem until it reaches the base case, where no further calls occur.

Recursive Function Structure

Any recursive function must contain two main elements:

1. Base case — condition where the function stops recursive calls.
2. Recursive call — calling itself with new arguments.

Example: Factorial

Factorial of number n (n!) is the product of all natural numbers from 1 to n.

function factorial(n: number): number {
  if (n === 1) return 1;         // Base case
  return n * factorial(n - 1);   // Recursive call
}

console.log(factorial(5)); // 120

How it Works

Call factorial(5) will unfold like:

factorial(5)
= 5 * factorial(4)
= 5 * 4 * factorial(3)
= 5 * 4 * 3 * factorial(2)
= 5 * 4 * 3 * 2 * factorial(1)
= 5 * 4 * 3 * 2 * 1
= 120

Example: Array Traversal with Recursion

function printArray(arr: number[], index = 0): void {
  if (index >= arr.length) return;
  console.log(arr[index]);
  printArray(arr, index + 1);
}

printArray([10, 20, 30, 40]);

Recursion vs Iteration

When to Use Recursion?

• Working with trees and graphs (DOM, file system, component tree)
• Parsing nested structures (e.g., HTML or JSON parsing)
• Algorithms: reverse traversal, backtracking, pathfinding

Conclusion

• Recursion is a way to solve problems by repeatedly calling a function on itself.
• There must always be a base case for exit.
• Used where problems can be broken into subproblems (especially in data structures).