Is there a sleep function in JavaScript?

javascript

async-await

timeout

promise

byAlex Kataev·Feb 25, 2025

Throttle JavaScript processing by using a 'sleep' function, backed by a Promise and leveraging setTimeout. Improve readability by making use of async/await. Eager to jump right in? Check the code below:

const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

// In an async function or an immediately-invoked function expression (IIFE)
(async () => {
  await sleep(2000); // Nap time for 2 seconds!
  console.log('Rise and shine, await is done sleeping!');
})();

await sleep(2000); imitates good old nap time for 2 seconds, without preventing other parts of your code to continue sprightly.

Crafting a hiatus with async/await

A seemingly synchronous flow can be designed using setTimeout, Promise and async/await. Sending your function to sleep without blocking the rest of your code prolongs its performance while making sure other parts of your program don't catch the dozing disease.

async function meticulousProcess() {
  console.log('I\'m on it.');
  await sleep(5000); // Well, a clock 5 second snooze won't hurt
  console.log('Ready for the next task!');
}

meticulousProcess();

The diligent function meticulousProcess takes a pause, waiting for the sleep Promise to fulfill before hustling to the next code operation.

Sleep's side gigs include...

Beyond its resume of being catching some Z's agent, setTimeout can be handy in scenarios requiring input debouncing, slowing API requests (throttling) or sequencing timed animations. So, it's not just about making the function snore!

For repeated delays, like flipping through the pages of an eBook or streaming data, setInterval(callback, interval) is at your service. The function perpetually executes a specific task at set time intervals until cleared.

Mastering the tick-tock of execution

setTimeout isn't just about halting processing. It's about weaving a flow of operations in a script language like JavaScript. Picture animation frames syncing to create a movie or async data fetches in sequence. Controlling the tempo can make the symphony of code interactions harmonious.

Here, we delay execution of multiple asynchronous operations:

for (const item of items) {
  await sleep(1000);
  // Perform an operation on each item with a 1s rest, to respect CPU's "me" time.
}

The above chunk ensures operations are conducted in a sequential manner, creating a fluid user experience and abiding by API rate limit restrictions.

Don't wear out the wake-up timer

While clever use of setTimeout can resemble a sleep function, understand that only the dark side of The Force deals in absolutes. Failing to properly clear timers can lead to memory leaks. And relying too heavily on setTimeout could leave you entangled in a bugs' web with erratic timing issues in complex applications.

Contingencies and altercations

There are complex scenarios where using a simple setTimeout might not cut it. In those instances, lean on Web Workers or Node.js child processes to run tasks in parallel to the main thread and coordinate using a message-passing interface.

Node.js developers, hear up! Modules like deasync offer a true sleep function. However, note the blocking nature of these methods. Consider using the timers/promises API that offers a promise-based version of setTimeout, which aligns snugly with the async/await paradigm.

Error-free napping

Incorporating sleep behavior with robust error handling is vital. Wrap your delayed operation in a try/catch block within an async function and you're all set.

async function handleDelayWithCare() {
  try {
    await sleep(2000);
    // If something is going to go wrong, it'll be here.
  } catch (error) {
    console.error('Oops, something went bump in the night!', error);
  }
}