Stack overflow concept in Javascript

Introduction

A stack overflow happens when a program uses more space in the call stack than it has. This usually occurs because of too many nested function calls.

When you want to understand why a program crashes with a 'stack overflow' error.

When debugging recursive functions that might call themselves too many times.

When learning how computer memory works for function calls.

When optimizing code to avoid too deep or infinite recursion.

When designing algorithms that use recursion and need to be safe.

Syntax

Javascript

function recursiveFunction(count) {
  if (count <= 0) {
    return 'Done';
  }
  return recursiveFunction(count - 1);
}

// Calling with a very large number may cause stack overflow
recursiveFunction(1000000);

This example shows a simple recursive function that calls itself.

If the number is too large, the program runs out of stack space and crashes.

Examples

Small count works fine and prints 'Done'.

Javascript

function recursiveFunction(count) {
  if (count <= 0) {
    return 'Done';
  }
  return recursiveFunction(count - 1);
}

console.log(recursiveFunction(3));

Zero count returns immediately without recursion.

Javascript

function recursiveFunction(count) {
  if (count <= 0) {
    return 'Done';
  }
  return recursiveFunction(count - 1);
}

console.log(recursiveFunction(0));

Missing base case causes infinite recursion and stack overflow.

Javascript

function recursiveFunction(count) {
  // No base case causes infinite recursion
  return recursiveFunction(count);
}

// This will cause stack overflow immediately
recursiveFunction(1);

Sample Program

This program shows a safe recursive call with count 5, which works fine.

Then it tries a very large count that causes a stack overflow error, caught and printed.

Javascript

function recursiveFunction(count) {
  if (count <= 0) {
    return 'Done';
  }
  return recursiveFunction(count - 1);
}

console.log('Calling with count = 5');
console.log(recursiveFunction(5));

console.log('Calling with count = 1000000 (may cause stack overflow)');
try {
  recursiveFunction(1000000);
} catch (error) {
  console.log('Error:', error.message);
}

Important Notes

Time complexity depends on the number of recursive calls, here O(n).

Space complexity is also O(n) because each call uses stack space.

Common mistake: forgetting the base case causes infinite recursion and stack overflow.

Use iteration or tail recursion optimization to avoid stack overflow if possible.

Summary

Stack overflow happens when too many function calls use up the call stack memory.

Recursive functions need a base case to stop calling themselves.

Large or infinite recursion causes stack overflow errors.

Practice

1. What causes a stack overflow error in JavaScript?

easy

A. Declaring global variables

B. Using too many variables in a function

C. Too many nested function calls without stopping

D. Calling a function only once

Solution

1. Step 1: Understand what the call stack is

   The call stack keeps track of function calls in JavaScript. Each call uses some memory.

2. Step 2: Identify what causes overflow

   If functions call themselves too many times without stopping, the stack runs out of memory, causing overflow.

3. Final Answer:

   Too many nested function calls without stopping -> Option C

4. Quick Check:

   Stack overflow = too many nested calls [OK]

Hint: Stack overflow = infinite or too deep recursion [OK]

Common Mistakes:

• Thinking global variables cause stack overflow
• Confusing variable count with call stack size
• Assuming single function call causes overflow

2. Which of the following JavaScript function definitions will cause a stack overflow when called?

easy

A. function infinite() { infinite(); }

B. function countDown(n) { if(n <= 0) return; countDown(n - 1); }

C. function greet() { console.log('Hello'); }

D. function add(a, b) { return a + b; }

Solution

1. Step 1: Check each function for recursion

   function countDown(n) { if(n <= 0) return; countDown(n - 1); } has a base case stopping recursion. function infinite() { infinite(); } calls itself endlessly without a base case. Options C and D are normal functions without recursion.

2. Step 2: Identify which causes stack overflow

   Only function infinite() { infinite(); } causes infinite recursion, leading to stack overflow error.

3. Final Answer:

   function infinite() { infinite(); } -> Option A

4. Quick Check:

   Infinite recursion = stack overflow [OK]

Hint: Infinite recursion without base case causes overflow [OK]

Common Mistakes:

• Assuming all recursive functions cause overflow
• Ignoring base case in recursion
• Confusing normal functions with recursive ones

3. What will be the output of this code?

function recurse(n) {
  if (n === 0) return 'Done';
  return recurse(n - 1);
}
console.log(recurse(3));

medium

A. 3

B. Stack overflow error

C. undefined

D. "Done"

Solution

1. Step 1: Trace the recursive calls

   recurse(3) calls recurse(2), then recurse(1), then recurse(0). At n=0, it returns 'Done'.

2. Step 2: Return values propagate back

   Each call returns the result of the next call, so finally recurse(3) returns 'Done'.

3. Final Answer:

   "Done" -> Option D

4. Quick Check:

   Base case stops recursion, returns 'Done' [OK]

Hint: Base case returns value, recursion unwinds safely [OK]

Common Mistakes:

• Expecting stack overflow without base case
• Thinking recursion returns input number
• Ignoring return propagation

4. Find the error in this recursive function that causes a stack overflow:

function factorial(n) {
  return n * factorial(n - 1);
}

medium

A. Wrong multiplication operator

B. Missing base case to stop recursion

C. Function name is incorrect

D. Should use addition instead of multiplication

Solution

1. Step 1: Check for base case in recursion

   The function calls itself without any condition to stop, so recursion never ends.

2. Step 2: Understand stack overflow cause

   Without a base case, calls pile up until memory runs out, causing stack overflow.

3. Final Answer:

   Missing base case to stop recursion -> Option B

4. Quick Check:

   Base case missing = infinite recursion [OK]

Hint: Always add base case to recursive functions [OK]

Common Mistakes:

• Assuming multiplication causes error
• Ignoring need for base case
• Thinking function name affects recursion

5. You want to safely calculate the sum of numbers from 1 to n using recursion without causing stack overflow. Which change should you make to this function?

function sum(n) {
  return n + sum(n - 1);
}

hard

A. Add a base case: if (n <= 0) return 0;

B. Change + to * operator

C. Call sum(n + 1) instead

D. Remove the recursive call

Solution

1. Step 1: Identify missing base case

   The function calls itself with n-1 but never stops, causing overflow.

2. Step 2: Add base case to stop recursion

   Adding if (n <= 0) return 0; stops recursion when n reaches 0 or less.

3. Step 3: Confirm safe recursion

   With base case, recursion ends properly and sum is calculated without overflow.

4. Final Answer:

   Add a base case: if (n <= 0) return 0; -> Option A

5. Quick Check:

   Base case stops recursion safely [OK]

Hint: Base case prevents infinite recursion and overflow [OK]

Common Mistakes:

• Changing operator instead of adding base case
• Increasing n causing infinite recursion
• Removing recursion loses function purpose