Recursive setTimeout vs setInterval in Node.js

Introduction

We use timers to run code after some delay or repeatedly. Recursive setTimeout and setInterval both help with repeated actions but work differently.

When you want to run a task repeatedly but want to control the delay between each run carefully.

When the task duration varies and you want to wait for it to finish before scheduling the next run.

When you want to avoid overlapping runs of a repeated task.

When you want a simple repeated timer without worrying about task duration.

Syntax

Node.js

function recursiveTimeout() {
  setTimeout(() => {
    // task code here
    recursiveTimeout();
  }, delay);
}

const intervalId = setInterval(() => {
  // task code here
}, delay);

// To stop interval
clearInterval(intervalId);

setTimeout schedules a single run after delay.

Recursive setTimeout calls itself after each run, allowing flexible timing.

setInterval schedules repeated runs automatically every delay ms.

Examples

This runs the task every 1 second, but waits for the task to finish before scheduling next.

Node.js

function recursiveTimeout() {
  setTimeout(() => {
    console.log('Run task');
    recursiveTimeout();
  }, 1000);
}
recursiveTimeout();

This runs the task every 1 second automatically, regardless of task duration.

Node.js

const intervalId = setInterval(() => {
  console.log('Run task');
}, 1000);

// To stop after 5 seconds
setTimeout(() => clearInterval(intervalId), 5000);

Shows recursive setTimeout with variable task duration inside.

Node.js

function recursiveTimeout() {
  setTimeout(() => {
    console.log('Task started');
    // simulate variable task time
    setTimeout(() => {
      console.log('Task finished');
      recursiveTimeout();
    }, 500);
  }, 1000);
}
recursiveTimeout();

This setInterval runs every 1 second but task takes 1.5 seconds, causing overlap.

Node.js

const intervalId = setInterval(() => {
  console.log('Task running');
  // long task simulation
  const start = Date.now();
  while (Date.now() - start < 1500) {}
  console.log('Task done');
}, 1000);

Sample Program

This program first runs a recursive setTimeout that prints 5 times every 1 second. After it finishes, it starts a setInterval that also prints 5 times every 1 second.

You can see how both run repeated tasks but are controlled differently.

Node.js

function recursiveTimeoutExample() {
  let count = 0;
  function runTask() {
    console.log(`Recursive setTimeout run: ${count}`);
    count++;
    if (count < 5) {
      setTimeout(runTask, 1000);
    }
  }
  runTask();
}

function setIntervalExample() {
  let count = 0;
  const intervalId = setInterval(() => {
    console.log(`setInterval run: ${count}`);
    count++;
    if (count >= 5) {
      clearInterval(intervalId);
    }
  }, 1000);
}

console.log('Start recursiveTimeoutExample');
recursiveTimeoutExample();

setTimeout(() => {
  console.log('Start setIntervalExample');
  setIntervalExample();
}, 7000);

Important Notes

Time complexity: Both run tasks repeatedly; complexity depends on task inside.

Space complexity: Minimal, just timer references.

Recursive setTimeout avoids overlapping tasks by scheduling next run after current finishes.

setInterval can cause overlapping if task takes longer than interval delay.

Use recursive setTimeout when task duration varies or you want precise control.

Use setInterval for simple repeated tasks with fixed delay.

Summary

Recursive setTimeout schedules next run after current task finishes.

setInterval schedules repeated runs automatically at fixed intervals.

Choose recursive setTimeout to avoid overlapping and control timing better.