setInterval and clearInterval in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this Node.js code output?

Consider the following code snippet using setInterval and clearInterval. What will be printed to the console?

Node.js

let count = 0;
const intervalId = setInterval(() => {
  count++;
  console.log(count);
  if (count === 3) {
    clearInterval(intervalId);
  }
}, 1000);

A 1\n2\n3\n4 (then stops)

B 1\n2\n3 (then stops)

C 1\n2 (then stops)

D No output, code throws an error

💡 Hint

Think about when clearInterval stops the repeated action.

The interval runs every 1000ms, increasing count and printing it. When count reaches 3, clearInterval stops further calls, so output is 1, 2, 3 then stops.

📝 Syntax

intermediate

Which option correctly cancels a repeating timer?

You want to stop a repeating timer created by setInterval. Which of the following code snippets correctly cancels it?

Node.js

const timer = setInterval(() => console.log('tick'), 500);

A cancelInterval(timer);

B clearTimeout(timer);

C stopInterval(timer);

D clearInterval(timer);

💡 Hint

Remember the function name to stop intervals is similar to the one to start them.

clearInterval is the correct function to stop a timer created by setInterval. clearTimeout is for setTimeout. The others are invalid functions.

❓ state_output

advanced

What is the final value of counter after this code runs?

Analyze the code below. What will be the value of counter after 3500 milliseconds?

Node.js

let counter = 0;
const id = setInterval(() => {
  counter += 2;
  if (counter >= 6) {
    clearInterval(id);
  }
}, 1000);

A 6

B 8

C 4

D 0

💡 Hint

Count how many times the interval callback runs before stopping.

The interval runs every 1000ms, adding 2 each time. After 3 runs (at 3000ms), counter is 6 and the interval stops. At 3500ms, counter remains 6.

🔧 Debug

advanced

Why does this code print odd numbers (1, 3, 5...) repeatedly?

Look at this code snippet. It prints '1', '3', '5', etc. every second instead of sequential numbers. What is the cause?

Node.js

let i = 0;
setInterval(() => {
  i++;
  console.log(i++);
}, 1000);

A Because <code>i++</code> returns the value before increment, causing unexpected output.

B Because <code>i</code> is not initialized properly.

C Because <code>setInterval</code> callback is missing a return statement.

D Because <code>console.log</code> is called outside the interval.

💡 Hint

Check how the increment operator works when used inside console.log.

i++ is the post-increment operator, which returns the value before incrementing. The standalone i++ increments i but discards the old value. Then console.log(i++) prints the value before the second increment, resulting in 1, 3, 5, etc. The other options are incorrect.

🧠 Conceptual

expert

What happens if you call clearInterval with an invalid ID?

In Node.js, if you call clearInterval with a value that is not a valid interval ID, what will happen?

A The program crashes and exits.

B A runtime error is thrown immediately.

C Nothing happens; the call is ignored without error.

D The last interval created is cleared instead.

💡 Hint

Think about how Node.js handles invalid timer IDs safely.

Calling clearInterval with an invalid or non-existent ID does nothing and does not throw an error. This design prevents crashes from accidental calls.

Practice

1. What does the setInterval function do in Node.js?

easy

A. Runs a function only once after a delay

B. Stops a running timer

C. Runs a function repeatedly at specified time intervals

D. Schedules a function to run immediately

Solution

1. Step 1: Understand setInterval purpose

   setInterval schedules a function to run repeatedly every specified milliseconds.

2. Step 2: Compare with other timer functions

   setTimeout runs once after delay, clearInterval stops intervals.

3. Final Answer:

   Runs a function repeatedly at specified time intervals -> Option C

4. Quick Check:

   setInterval = repeated execution [OK]

Hint: setInterval repeats; setTimeout runs once [OK]

Common Mistakes:

• Confusing setInterval with setTimeout
• Thinking clearInterval starts timers
• Believing setInterval runs only once

2. Which of the following is the correct syntax to stop a repeating timer started with setInterval?

easy

A. clearInterval(timerId);

B. stopInterval(timerId);

C. clearTimeout(timerId);

D. cancelInterval(timerId);

Solution

1. Step 1: Identify the function to stop intervals

   clearInterval is the built-in function to stop intervals.

2. Step 2: Check other options

   clearTimeout stops timeouts, others are invalid functions.

3. Final Answer:

   clearInterval(timerId); -> Option A

4. Quick Check:

   clearInterval stops intervals [OK]

Hint: Use clearInterval with the interval ID [OK]

Common Mistakes:

• Using clearTimeout to stop intervals
• Using non-existent functions like stopInterval
• Not passing the timer ID to clearInterval

3. What will the following code output to the console?

let count = 0;
const id = setInterval(() => {
  count++;
  console.log(count);
  if (count === 3) clearInterval(id);
}, 1000);

medium

A. 1 2 3 (each number printed every second, then stops)

B. 1 2 3 4 5 (prints numbers every second indefinitely)

C. Only 3 printed once after 3 seconds

D. No output because clearInterval is called immediately

Solution

1. Step 1: Trace the interval execution

   Every 1000ms, count increases and prints. When count reaches 3, clearInterval stops it.

2. Step 2: Understand stopping condition

   After printing 3, the interval stops, so no further output.

3. Final Answer:

   1 2 3 (each number printed every second, then stops) -> Option A

4. Quick Check:

   Interval runs 3 times then stops [OK]

Hint: clearInterval inside callback stops after condition [OK]

Common Mistakes:

• Assuming it runs forever
• Thinking clearInterval stops immediately before first print
• Confusing setTimeout with setInterval

4. Identify the error in this code snippet:

const id = setInterval(() => {
  console.log('Hello');
});
clearInterval(id);

medium

A. No error, code works fine

B. clearInterval should be called inside the callback

C. setInterval cannot be assigned to a variable

D. Missing interval time argument in setInterval

Solution

1. Step 1: Check setInterval syntax

   setInterval requires two arguments: function and interval time in milliseconds.

2. Step 2: Analyze the code

   Here, the interval time is missing, causing a syntax error or unexpected behavior.

3. Final Answer:

   Missing interval time argument in setInterval -> Option D

4. Quick Check:

   setInterval needs delay argument [OK]

Hint: Always provide delay time in setInterval [OK]

Common Mistakes:

• Omitting the delay argument
• Calling clearInterval immediately without delay
• Thinking setInterval returns undefined

5. You want to print "Tick" every second but stop after 5 ticks. Which code correctly achieves this?

hard

A. setInterval(() => {
console.log('Tick');
clearInterval(timer);
}, 1000);

B. let ticks = 0;
const timer = setInterval(() => {
ticks++;
console.log('Tick');
if (ticks === 5) clearInterval(timer);
}, 1000);

C. let ticks = 0;
setTimeout(() => {
console.log('Tick');
if (ticks < 5) ticks++;
}, 1000);

D. const timer = setInterval(() => {
console.log('Tick');
if (ticks === 5) clearTimeout(timer);
}, 1000);

Solution

1. Step 1: Identify correct interval and stopping logic

   let ticks = 0; const timer = setInterval(() => { ticks++; console.log('Tick'); if (ticks === 5) clearInterval(timer); }, 1000); uses setInterval with a counter and calls clearInterval after 5 ticks.

2. Step 2: Check other options for errors

   setInterval(() => { console.log('Tick'); clearInterval(timer); }, 1000); clears immediately, let ticks = 0; setTimeout(() => { console.log('Tick'); if (ticks < 5) ticks++; }, 1000); uses setTimeout wrongly, const timer = setInterval(() => { console.log('Tick'); if (ticks === 5) clearTimeout(timer); }, 1000); uses clearTimeout instead of clearInterval.

3. Final Answer:

   let ticks = 0; const timer = setInterval(() => { ticks++; console.log('Tick'); if (ticks === 5) clearInterval(timer); }, 1000); -> Option B

4. Quick Check:

   Use counter and clearInterval after limit [OK]

Hint: Use a counter and clearInterval after limit [OK]

Common Mistakes:

• Calling clearInterval immediately
• Using clearTimeout to stop intervals
• Using setTimeout instead of setInterval for repeated tasks