Recursive setTimeout vs setInterval in Node.js - Practice Questions

Challenge - 5 Problems

❓ component_behavior

intermediate

Output of recursive setTimeout vs setInterval timing

Consider the following Node.js code snippets. What will be the output behavior of each snippet over 3 seconds?

Snippet 1 uses setInterval to print a message every 1 second.
Snippet 2 uses recursive setTimeout to print a message every 1 second.

Which statement best describes the difference in their output timing?

Node.js

Snippet 1:
setInterval(() => {
  console.log('Interval tick');
}, 1000);

Snippet 2:
function recursiveTimeout() {
  console.log('Timeout tick');
  setTimeout(recursiveTimeout, 1000);
}
recursiveTimeout();

A Both methods cause overlapping executions if the callback takes longer than 1 second.

B Both print exactly every 1 second with no delay accumulation.

C setInterval waits for the callback to finish before next tick; recursive setTimeout runs ticks in parallel causing overlap.

D setInterval prints every 1 second regardless of execution time; recursive setTimeout waits for the callback to finish before scheduling next, preventing overlap.

💡 Hint

Think about how each method schedules the next execution relative to the callback duration.

setInterval schedules the callback every fixed interval regardless of how long the callback takes, which can cause overlapping if the callback is slow. Recursive setTimeout schedules the next call only after the current callback finishes, avoiding overlap and allowing dynamic intervals.

📝 Syntax

intermediate

Identify the syntax error in recursive setTimeout usage

Which option contains a syntax error that prevents the recursive setTimeout from working correctly?

Node.js

function tick() {
  console.log('Tick');
  setTimeout(tick, 1000)
}

A

function tick() {
  console.log('Tick');
  setTimeout(tick 1000);
}

B

function tick() {
  console.log('Tick');
  setTimeout(tick, 1000);
}

C

function tick() {
  console.log('Tick');
  setTimeout(tick, '1000');
}

D

function tick() {
  console.log('Tick');
  setTimeout(tick, 1000)
}

💡 Hint

Check the syntax of the setTimeout function call arguments.

Option A is missing a comma between the function reference and the delay argument, causing a syntax error. Other options have correct syntax; passing delay as string (option A) is allowed but not recommended.

❓ state_output

advanced

State after 3 recursive setTimeout calls with varying delays

Given this code, what will be the value of count after approximately 3500 milliseconds?

Node.js

let count = 0;
function tick() {
  count++;
  console.log('Tick', count);
  setTimeout(tick, count * 1000);
}
tick();

A count will be 1

B count will be 2

C count will be 3

D count will be 4

💡 Hint

Each delay increases by 1000ms multiplied by the current count.

The first tick runs immediately (count=1), schedules next after 1000ms, second tick (count=2) schedules next after 2000ms, third tick (count=3) schedules next after 3000ms. After ~3500ms, three ticks have occurred.

🔧 Debug

advanced

Why does this recursive setTimeout cause a memory leak?

Examine this code snippet. Why might it cause increasing memory usage over time?

Node.js

function tick() {
  setTimeout(() => {
    console.log('Tick');
    tick();
  }, 1000);
}
tick();

A Because tick is called inside setTimeout, causing infinite recursion without delay.

B Because each setTimeout callback creates a new closure that references the previous one, causing memory to accumulate.

C Because setTimeout is called inside an arrow function, which leaks memory in Node.js.

D Because the console.log inside setTimeout causes memory to grow indefinitely.

💡 Hint

Think about how closures capture variables and references in recursive asynchronous calls.

Each arrow function passed to setTimeout forms a closure capturing the previous context. Over time, these nested closures accumulate, causing increased memory usage.

🧠 Conceptual

expert

Choosing between setInterval and recursive setTimeout for precise timing

You need to run a task every 1000ms, but the task duration varies and can sometimes take longer than 1000ms. Which approach ensures the task never overlaps and runs immediately after the previous finishes?

A Use recursive setTimeout scheduling the next call only after the current task finishes.

B Use setInterval with 1000ms delay; it queues tasks even if previous is still running.

C Use setInterval but clear and reset it inside the callback to prevent overlap.

D Use recursive setTimeout with a fixed 1000ms delay regardless of task duration.

💡 Hint

Consider how each method handles task duration longer than the interval.

Recursive setTimeout schedules the next call only after the current task completes, preventing overlap. setInterval fires at fixed intervals regardless of task duration, causing overlap if tasks take longer.