Infinite recursion causing stack overflow

Infinite Recursion Causing Stack Overflow in JavaScript: A Detailed Explanation

Infinite recursion is a common programming issue that can cause a stack overflow error in JavaScript. This happens when a function keeps calling itself indefinitely without a base condition to stop the recursion. The call stack eventually exceeds the allocated memory, leading to the program crashing with an error like:

Uncaught RangeError: Maximum call stack size exceeded

Let’s break this down step by step.

---

1. Understanding Recursion

Recursion is a technique where a function calls itself in order to solve a problem. Every recursive function must have a base case, which acts as the stopping condition.

Example of Proper Recursion

function countdown(n) {
    if (n <= 0) {  // Base case
        console.log("Done!");
        return;
    }
    console.log(n);
    countdown(n - 1);  // Recursive call with a smaller value
}

countdown(5);

Output:

5
4
3
2
1
Done!

Here, the function stops calling itself when n <= 0, preventing infinite recursion.

---

2. What Causes Infinite Recursion?

Infinite recursion happens when:

• No base case is defined
• The base case is incorrectly written
• The recursive call does not move towards the base case
• Unintended mutual recursion occurs (two functions calling each other indefinitely)

Example 1: No Base Case (Infinite Recursion)

function infinite() {
    console.log("Calling infinite function...");
    infinite(); // Function keeps calling itself without stopping
}

infinite();

❌ This will result in a stack overflow error because the function never stops calling itself.

Example 2: Incorrect Base Case

function faultyCountdown(n) {
    if (n > 0) {  // Incorrect stopping condition
        console.log(n);
        faultyCountdown(n + 1);  // Recursive call moves AWAY from stopping condition
    }
}

faultyCountdown(1);

Here, n is increasing instead of decreasing, so the function never reaches a stopping point.

Example 3: Mutual Recursion Without Exit Condition

function A() {
    console.log("Function A called");
    B();
}

function B() {
    console.log("Function B called");
    A();
}

A();

❌ This will result in infinite mutual recursion, as A calls B, which calls A, and so on.

---

3. How to Prevent Infinite Recursion?

To prevent stack overflow errors caused by infinite recursion, follow these best practices:

✅ Always Include a Base Case

A base case is a condition that stops the recursion.

function safeCountdown(n) {
    if (n <= 0) {  // Stopping condition
        console.log("Done!");
        return;
    }
    console.log(n);
    safeCountdown(n - 1);
}

safeCountdown(5);

✅ Ensure Progress Toward the Base Case

If the recursive call does not reduce the problem towards the base case, recursion will continue indefinitely.

function factorial(n) {
    if (n <= 1) return 1;  // Base case
    return n * factorial(n - 1);  // Moves towards base case
}

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

✅ Use Iteration Instead of Recursion (If Needed)

Some problems are better solved using loops rather than recursion.

function factorialIterative(n) {
    let result = 1;
    for (let i = n; i > 1; i--) {
        result *= i;
    }
    return result;
}

console.log(factorialIterative(5)); // Output: 120

✅ Set a Maximum Recursion Depth

If recursion depth is a concern, limit the number of calls.

function limitedRecursion(n, depth = 0, maxDepth = 100) {
    if (depth > maxDepth) {
        console.log("Recursion limit reached, stopping.");
        return;
    }
    console.log(n);
    limitedRecursion(n - 1, depth + 1, maxDepth);
}

limitedRecursion(10);

---

4. Handling Stack Overflow Errors

If you encounter a “Maximum call stack size exceeded” error:

1. Check if the function has a base case.
2. Ensure the recursive call progresses toward the base case.
3. Consider using iteration instead of recursion.
4. Use tail recursion optimization if applicable (some JavaScript engines optimize tail calls).

Example: Tail Recursion Optimization

function tailRecFactorial(n, acc = 1) {
    if (n <= 1) return acc;
    return tailRecFactorial(n - 1, acc * n);
}

console.log(tailRecFactorial(5)); // Output: 120

Tail recursion can be more memory-efficient in languages that support tail call optimization.

---

5. Summary

• Recursion is when a function calls itself.
• Infinite recursion happens when there’s no base case or the recursive call doesn’t approach the base case.
• Stack overflow errors occur when recursion runs indefinitely.
• Prevent infinite recursion by defining base cases, ensuring progress, and using iteration if needed.
• Debug stack overflow errors by checking stopping conditions and tracing recursive calls.

By following these best practices, you can write efficient recursive functions while avoiding infinite loops and stack overflow errors.