Call stack behavior in Javascript - Step-by-Step Execution

Concept Flow - Call stack behavior

Start main program

↓

Call function A

↓

Call function B inside A

↓

Call function C inside B

↓

Function C returns

↓

Function B returns

↓

Function A returns

↓

Program ends

The call stack tracks function calls in order. Each call adds a frame on top. When a function finishes, its frame is removed, returning control to the previous function.

Execution Sample

Javascript

function A() {
  B();
}
function B() {
  C();
}
function C() {
  console.log('Done');
}
A();

This code calls A, which calls B, which calls C, printing 'Done'. The call stack grows and shrinks as functions call and return.

Execution Table

Step	Action	Call Stack (top to bottom)	Output
1	Start program	[]
2	Call A()	[A]
3	Inside A(), call B()	[B, A]
4	Inside B(), call C()	[C, B, A]
5	Inside C(), execute console.log('Done')	[C, B, A]	Done
6	C() returns	[B, A]
7	B() returns	[A]
8	A() returns	[]
9	Program ends	[]

💡 All functions returned, call stack is empty, program ends.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	After Step 8	Final
callStack	[]	[A]	[B, A]	[C, B, A]	[C, B, A]	[B, A]	[A]	[]	[]
output	""	""	""	""	"Done"	"Done"	"Done"	"Done"	"Done"

Key Moments - 3 Insights

Why does the call stack grow when a function calls another function?

Each function call adds a new frame on top of the stack to keep track of where to return after the called function finishes, as shown in steps 2 to 4 in the execution table.

When does a function frame get removed from the call stack?

A function frame is removed when the function finishes execution and returns control to the caller, as seen in steps 6 to 8 where C, B, and A return respectively.

Why is the output 'Done' printed only when C() is called?

Because console.log('Done') is inside function C, so the output appears at step 5 when C() executes, while the call stack still contains C, B, and A.

Visual Quiz - 3 Questions

Look at the execution table, what is the call stack after step 4?

A [C, B, A]

B [B, A]

C [A]

D []

💡 Hint

Check the 'Call Stack' column at step 4 in the execution table.

At which step does function B return and get removed from the call stack?

A Step 5

B Step 7

C Step 6

D Step 8

💡 Hint

Look for when B disappears from the call stack in the execution table.

If function C did not call console.log, what would be the output after step 5?

A Error

B "Done"

C "" (empty string)

D Undefined

💡 Hint

Refer to the 'Output' column in the execution table at step 5.

Concept Snapshot

Call stack tracks function calls in order.
Each call adds a frame on top.
When a function returns, its frame is removed.
Stack grows with nested calls, shrinks on returns.
Helps JavaScript know where to resume after calls.

Full Transcript

The call stack is a structure that keeps track of function calls in JavaScript. When the program starts, the stack is empty. Calling function A adds A to the stack. Inside A, calling B adds B on top. Inside B, calling C adds C on top. When C runs console.log('Done'), it prints 'Done'. After C finishes, it returns and is removed from the stack. Then B returns and is removed, then A returns and is removed. Finally, the stack is empty and the program ends. This shows how the call stack grows with calls and shrinks with returns, helping JavaScript manage function execution order.

Practice

1. What does the call stack do in JavaScript?

easy

A. Keeps track of function calls in the order they are called

B. Stores variables and their values

C. Manages asynchronous events

D. Handles network requests

Solution

1. Step 1: Understand the role of the call stack

   The call stack tracks which functions are currently running and in what order.

2. Step 2: Differentiate from other JavaScript components

   Variables are stored in memory, asynchronous events are handled by the event loop, and network requests are managed separately.

3. Final Answer:

   Keeps track of function calls in the order they are called -> Option A

4. Quick Check:

   Call stack = function order tracking [OK]

Hint: Call stack = function call order tracker [OK]

Common Mistakes:

• Confusing call stack with event loop
• Thinking call stack stores variables
• Mixing call stack with network handling

2. Which of the following is the correct way to call a function named foo in JavaScript?

easy

A. call foo();

B. function foo();

C. execute foo();

D. foo();

Solution

1. Step 1: Recall JavaScript function call syntax

   Functions are called by writing their name followed by parentheses, like foo();.

2. Step 2: Identify incorrect options

   "call foo();" and "execute foo();" are not valid JavaScript syntax. "function foo();" is a function declaration, not a call.

3. Final Answer:

   foo(); -> Option D

4. Quick Check:

   Function call = name + () [OK]

Hint: Call functions with name and parentheses () [OK]

Common Mistakes:

• Using 'call' keyword incorrectly
• Confusing declaration with call
• Adding extra keywords like 'execute'

3. What will be the output of the following code?

function first() {
  console.log('first');
  second();
  console.log('first again');
}

function second() {
  console.log('second');
}

first();

medium

A. second\nfirst\nfirst again

B. first\nsecond\nfirst again

C. first\nfirst again\nsecond

D. first again\nsecond\nfirst

Solution

1. Step 1: Trace the call stack execution order

   Calling first() prints 'first', then calls second() which prints 'second'. After second() finishes, control returns to first() and prints 'first again'.

2. Step 2: Confirm output sequence

   The output lines are: 'first', 'second', 'first again' in that order.

3. Final Answer:

   first second first again -> Option B

4. Quick Check:

   Call stack order = first, second, first again [OK]

Hint: Follow function calls step-by-step [OK]

Common Mistakes:

• Assuming all logs run before second()
• Mixing order of console logs
• Ignoring return to first() after second()

4. Identify the error in the following code related to call stack behavior:

function a() {
  b();
}

function b() {
  a();
}

a();

medium

A. Function b is not defined

B. Syntax error due to missing semicolons

C. Infinite recursion causing stack overflow

D. No error, code runs fine

Solution

1. Step 1: Analyze function calls and recursion

   Function a() calls b(), and b() calls a() again, creating an endless loop.

2. Step 2: Understand call stack impact

   This infinite mutual recursion causes the call stack to grow until it overflows, leading to a runtime error.

3. Final Answer:

   Infinite recursion causing stack overflow -> Option C

4. Quick Check:

   Mutual recursion without stop = stack overflow [OK]

Hint: Watch for functions calling each other endlessly [OK]

Common Mistakes:

• Thinking missing semicolons cause error
• Assuming functions are undefined
• Believing code runs without error

5. Consider this code:

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

console.log(factorial(3));

How many times is the factorial function added to the call stack during factorial(3) execution?

hard

A. 4 times

B. 6 times

C. 1 time

D. 3 times

Solution

1. Step 1: Trace recursive calls for factorial(3)

   Calls happen for n=3, n=2, n=1, and n=0. Each call adds a new frame to the call stack.

2. Step 2: Count total calls added to the stack

   There are 4 calls total before reaching the base case (n=0), so 4 stack frames are added.

3. Final Answer:

   4 times -> Option A

4. Quick Check:

   Recursive calls = n+1 stack frames [OK]

Hint: Count calls including base case for recursion [OK]

Common Mistakes:

• Counting only n times, missing base case call
• Confusing total calls with return steps
• Assuming single call for recursion