Call stack behavior in Javascript

Introduction

The call stack helps the computer keep track of which function is running and what to do next. It works like a stack of plates, where the last one added is the first one removed.

When you want to understand how functions call each other step-by-step.

When debugging errors that say 'Maximum call stack size exceeded'.

When learning how recursion works in JavaScript.

When you want to know why some functions run before others.

Syntax

Javascript

function functionName() {
  // code here
  anotherFunction();
}

function anotherFunction() {
  // code here
}

functionName();

Each time a function is called, it is added (pushed) to the call stack.

When a function finishes, it is removed (popped) from the call stack.

Examples

Simple function call. The call stack adds 'greet', runs it, then removes it.

Javascript

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

Function 'first' calls 'second'. 'second' runs first, then 'first' continues.

Javascript

function first() {
  second();
  console.log('First done');
}
function second() {
  console.log('Second running');
}
first();

Recursive calls add multiple frames to the call stack until the base case is reached.

Javascript

function recursive(count) {
  if (count <= 0) return;
  console.log(count);
  recursive(count - 1);
}
recursive(3);

Even an empty function call adds and removes a frame on the call stack.

Javascript

function empty() {}
empty();

Sample Program

This program shows how the call stack works when functions call each other. You see the order of messages as functions are added and removed from the stack.

Javascript

function firstFunction() {
  console.log('Start firstFunction');
  secondFunction();
  console.log('End firstFunction');
}

function secondFunction() {
  console.log('Start secondFunction');
  thirdFunction();
  console.log('End secondFunction');
}

function thirdFunction() {
  console.log('Inside thirdFunction');
}

console.log('Program start');
firstFunction();
console.log('Program end');

Important Notes

Time complexity depends on the functions called, but call stack operations (push/pop) are very fast.

Space complexity grows with the number of nested function calls on the stack.

Common mistake: forgetting that functions run completely before the caller continues.

Use call stack understanding to debug recursion and function call order.

Summary

The call stack keeps track of function calls in order.

Functions are added to the stack when called and removed when done.

Understanding call stack helps with debugging and learning recursion.