Recursive setTimeout vs setInterval in Node.js - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to schedule a function to run repeatedly using setInterval.

Node.js

setInterval(() => {
  console.log('Hello every second');
}, [1]);

Drag options to blanks, or click blank then click option'

A1000

B5000

C10

D100

Attempts:

3 left

💡 Hint

Common Mistakes

Using 100 instead of 1000 causes the function to run every 0.1 seconds.

Using 5000 runs the function every 5 seconds, which is slower than intended.

The setInterval function takes the delay in milliseconds as the second argument. To run every second, use 1000 ms.

2fill in blank

medium

Complete the code to create a recursive setTimeout that logs 'Tick' every 2 seconds.

Node.js

function tick() {
  console.log('Tick');
  setTimeout(tick, [1]);
}
tick();

Drag options to blanks, or click blank then click option'

A500

B1000

C2000

D3000

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1000 causes the function to run every 1 second instead of 2.

Using 3000 causes the function to run every 3 seconds, which is slower.

The recursive setTimeout calls itself after the delay. To run every 2 seconds, use 2000 ms.

3fill in blank

hard

Fix the error in the recursive setTimeout code to avoid multiple overlapping calls.

Node.js

function repeat() {
  console.log('Running');
  [1](() => {
    repeat();
  }, 1000);
}
repeat();

Drag options to blanks, or click blank then click option'

AsetInterval

BsetTimeout

CclearTimeout

DclearInterval

Attempts:

3 left

💡 Hint

Common Mistakes

Using setInterval causes the function to run repeatedly without waiting for the previous call to finish.

Using clearTimeout or clearInterval here is incorrect because they cancel timers.

Using setTimeout recursively schedules the next call after the current one finishes, avoiding overlaps.

4fill in blank

hard

Fill both blanks to create a recursive setTimeout that stops after 5 runs.

Node.js

let count = 0;
function run() {
  if (count [1] 5) {
    console.log('Run number', count);
    count++;
    setTimeout(run, [2]);
  }
}
run();

Drag options to blanks, or click blank then click option'

A<

B<=

C1000

D500

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= 5 causes the function to run 6 times instead of 5.

Using 500 ms delay runs the function twice as fast as intended.

The condition count < 5 stops after 5 runs. The delay 1000 ms makes it run every second.

5fill in blank

hard

Fill all three blanks to create a recursive setTimeout that counts down from 3 and then stops.

Node.js

let num = 3;
function countdown() {
  if (num [1] 0) {
    console.log(num);
    num [2] 1;
    setTimeout(countdown, [3]);
  } else {
    console.log('Done!');
  }
}
countdown();

Drag options to blanks, or click blank then click option'

A>

B-=

C1000

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using < 0 causes the countdown to never stop.

Using += 1 increases num and causes an infinite loop.

Using delay other than 1000 changes the timing.

The countdown stops when num > 0 is false. The -= 1 decreases the number by one each time. The delay 1000 ms makes it run every second.

Practice

1. What is the main difference between setInterval and recursive setTimeout in Node.js?

easy

A. setInterval can only run synchronous code, recursive setTimeout can run asynchronous code.

B. setInterval runs tasks at fixed intervals regardless of task duration, recursive setTimeout waits for the task to finish before scheduling the next.

C. setInterval runs only once, recursive setTimeout runs repeatedly.

D. setInterval automatically adjusts intervals based on task duration, recursive setTimeout does not.

Solution

1. Step 1: Understand setInterval behavior

   setInterval schedules a function to run repeatedly at fixed time intervals without waiting for the previous run to finish.

2. Step 2: Understand recursive setTimeout behavior

   Recursive setTimeout schedules the next run only after the current function completes, avoiding overlap.

3. Final Answer:

   setInterval runs tasks at fixed intervals regardless of task duration, recursive setTimeout waits for the task to finish before scheduling the next. -> Option B

4. Quick Check:

   Task overlap control [OK]

Hint: Remember: recursive waits, interval runs fixed times [OK]

Common Mistakes:

• Thinking setInterval waits for task completion
• Confusing recursive setTimeout with single timeout
• Assuming setInterval adjusts timing automatically

2. Which of the following is the correct syntax to implement a recursive setTimeout that logs "Hello" every 2 seconds?

easy

A. setTimeout(() => { console.log('Hello'); }, 2000); setTimeout(() => { console.log('Hello'); }, 2000);

B. setInterval(() => { console.log('Hello'); }, 2000);

C. function repeat() { setTimeout(() => { console.log('Hello'); repeat(); }, 2000); } repeat();

D. function repeat() { setInterval(() => { console.log('Hello'); repeat(); }, 2000); } repeat();

Solution

1. Step 1: Identify recursive setTimeout pattern

   The function calls setTimeout inside itself after logging, ensuring repeated delayed calls.

2. Step 2: Check syntax correctness

   function repeat() { setTimeout(() => { console.log('Hello'); repeat(); }, 2000); } repeat(); defines a function that calls itself inside setTimeout, then starts it by calling repeat().

3. Final Answer:

   function repeat() { setTimeout(() => { console.log('Hello'); repeat(); }, 2000); } repeat(); -> Option C

4. Quick Check:

   Recursive call inside setTimeout [OK]

Hint: Recursive setTimeout calls itself inside timeout [OK]

Common Mistakes:

• Using setInterval instead of recursive setTimeout
• Not calling the recursive function initially
• Calling setTimeout multiple times without recursion

3. Consider this code snippet:

let count = 0;
function tick() {
  console.log(count);
  count++;
  if (count < 3) {
    setTimeout(tick, 1000);
  }
}
tick();

What will be the output and timing behavior?

medium

A. Logs 0 once, then stops without further logs.

B. Logs 0, 1, 2 immediately without delay, then stops.

C. Logs 0, 1, 2 every 1 second simultaneously, overlapping.

D. Logs 0, 1, 2 each after 1 second delay sequentially, then stops.

Solution

1. Step 1: Analyze recursive setTimeout calls

   Function tick logs count, increments it, and schedules next call after 1 second if count < 3.

2. Step 2: Trace output and timing

   Logs 0 immediately, then after 1s logs 1, after another 1s logs 2, then stops because count reaches 3.

3. Final Answer:

   Logs 0, 1, 2 each after 1 second delay sequentially, then stops. -> Option D

4. Quick Check:

   Recursive timeout delays [OK]

Hint: Recursive timeout delays each call by 1 second [OK]

Common Mistakes:

• Assuming logs happen immediately without delay
• Thinking logs overlap simultaneously
• Confusing setTimeout with setInterval behavior

4. Identify the problem in this code using recursive setTimeout:

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

medium

A. The function calls itself immediately causing a stack overflow.

B. The timeout delay is too short to see output.

C. The console.log is outside the timeout callback.

D. The function never calls itself, so it runs only once.

Solution

1. Step 1: Examine recursion timing

   The function repeat calls itself immediately after scheduling setTimeout, without waiting for the timeout to finish.

2. Step 2: Identify consequence

   This causes infinite immediate recursion, leading to stack overflow before any timeout callback runs.

3. Final Answer:

   The function calls itself immediately causing a stack overflow. -> Option A

4. Quick Check:

   Immediate recursion without delay [OK]

Hint: Call recursive function inside timeout callback only [OK]

Common Mistakes:

• Placing recursive call outside timeout callback
• Assuming timeout delays recursion automatically
• Ignoring stack overflow risk

5. You want to run a task every 3 seconds but ensure the task never overlaps if it takes longer than 3 seconds. Which approach is best?

hard

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

B. Use setInterval with 3000ms delay and ignore task duration.

C. Use setTimeout once without recursion.

D. Use setInterval with 1000ms delay and check task status inside.

Solution

1. Step 1: Understand overlap risk with setInterval

   setInterval runs tasks at fixed intervals regardless of task duration, causing overlap if task takes longer than interval.

2. Step 2: Use recursive setTimeout to control timing

   Recursive setTimeout schedules the next run only after the current task finishes, preventing overlap.

3. Final Answer:

   Use recursive setTimeout scheduling the next call only after task finishes. -> Option A

4. Quick Check:

   Prevent overlap with recursive timeout [OK]

Hint: Recursive timeout waits for task end before next call [OK]

Common Mistakes:

• Using setInterval ignoring task duration
• Not scheduling next call after task completion
• Using too short intervals causing overlap