Where’s the Sleep Function in JavaScript?

aumayeung profile image John Au-Yeung ・4 min read

Subscribe to my email list now at http://jauyeung.net/subscribe/

Follow me on Twitter at https://twitter.com/AuMayeung

Many more articles at https://medium.com/@hohanga

Even more articles at http://thewebdev.info/

If we try to search for the sleep function in JavaScript, we won’t find it. However, we can easily make one with existing functions.

setTimeout Function

There’s a setTimeout function that lets us run code after a specified number of milliseconds. We can use it to create our own sleep function.

Like most time-sensitive JavaScript code, it’s going to be asynchronous since this won’t hold up the main thread running our program.

We can create a function that runs code after a specified amount of time by writing:

const runLater = (delay) => {  
  setTimeout(() => {  
  }, delay)  

The runLater function will show the string 'bar' when we pass in the delay by in number of milliseconds.

If we run:


We’ll see that we get:


This is because the synchronous code, which are the first and last lines, are run first. The runLater(100) is queued up to be run in the next iteration of the event loop between the time when the first and last lines are run.

Then in the next iteration of the event loop, the code in the setTimeout callback runs, which will log 'baz' .

This means that if we want to run code in callbacks sequentially, we have to nest the callbacks. And too many callbacks create callback hell.


Therefore, the best way to run asynchronous JavaScript code sequentially is to use promises. We can create a promise with the setTimeout function by using the Promise constructor.

We can write the sleep function as follows:

const sleep = (delay) => {  
  return new Promise(resolve => {  
    setTimeout(resolve, delay)  

The sleep function returns a promise which resolves after the setTimeout callback, which is the resolve function is called after delay milliseconds.

A promise is asynchronous like the setTimeout callback. The good thing about it is that we can run them sequentially as they’re fulfilled.

Fulfilled means that the resolve method in the callback above is called. A promise can also be rejected with the reject function when an error occurs.

Using promises let us chain asynchronous code and run them sequentially.

We can do this cleanly with async functions. To define an async function, we use the async and await keywords as follows:

(async ()=>{  
  await sleep(2000);  

If we run the code above, we should see that 'foo' is logged, then 2 seconds after that 'bar' is logged.

This will let us up time delayed code without hanging our app.

The number 2000 in the argument is in milliseconds, so it’ll wait 2 seconds before running the next line.

await tells the browser to hold off on executing the next line until the await line is resolved. We can put await in front of any promise to indicate that we should wait for the promise to resolve before continuing.

We can keep repeating this:

(async () => {  
  await sleep(2000);  
  await sleep(2000);  
  await sleep(2000);  

But it gets repetitive. Fortunately, we can use loops to eliminate this repetition.

For-Await-Of Loop

We have the for-await-of loop which loops through iterable objects like arrays and array-like objects whether they’re synchronous or asynchronous.

To do this, we can write:

(async () => {  
  const arr = ['foo', 'bar', 'a', 'b'];  
  for await (let a of arr) {  
    await sleep(2000);  

The code above is much cleaner and it doesn’t matter how many things we want to loop through.

It’s important that we actually have promise code inside our async functions whether we want to use loops or not.

We can also return a promise from an async function, so we can write:

(async () => {  
  const arr = ['foo', 'bar', 'a', 'b'];  
  for await (let a of arr) {  
    await sleep(2000);  
  return sleep(2000);  

to return the sleep(2000) promise.

Also, we can give it a name and use it in other async functions as follows:

const foo = async () => {  
  const arr = ['foo', 'bar', 'a', 'b'];  
  for await (let a of arr) {  
    await sleep(2000);  
  return sleep(2000);  

(async () => {  
  await foo();  

This shows that async functions are promises.


In JavaScript, there’s no sleep function like in other languages. However, we can make our own easily.

With promises, we can solve timing issues easily. It makes time-delayed code execution clean and readable. We can write a time-delayed JavaScript code by using the setTimeout function.

The async and await syntax makes reading and writing the code a breeze.

Finally, we can call async functions in other async functions since these types of functions return promises only.

Posted on by:

aumayeung profile

John Au-Yeung


I'm web developer interested in JavaScript stuff.


Editor guide

Great article! In NodeJS I usually prefer the one-liner version:

const sleep = require('util').promisify(setTimeout);

The docs say it only works if the original function takes the callback as the final argument, setTimeout takes the callback as the first argument. Does this code even work? nodejs.org/dist/latest-v8.x/docs/a...


Functions can define their own promisified version using a symbol, which is what setTimeout does in Node.js

So yes, it works.

That makes sense. Good to know if we're using Node.js


I think it got to be a Node.js style callback with err as the first parameter.

Nonsense. It depends on a lot of attributes (engine, hardware) to determine the speed of one iteration.
Good engine would not spend 1ms per iteration, it would spend only a fraction of it.
Your code just doesn't make sense and wouldn't work.

You are promoting that function as a hacky alternative sleep implementation. It's not. It's not hacky and it's not an alternative.

Why would anyone implement "improvisation" for case that sleep function sleeps for fraction of the desired time.


This only works if each iteration runs for a millisecond, doesn't it?


Each iteration in the above code runs much faster than 1ms.
But it doesn't actually matters, because as Calin said this is an unaccepted way of implementing sleep function, because it blocks main thread and loads CPU at 100% for no profit.

Btw, setTimeout(fn, 2000) doesn't mean that fn will be called exactly after 2s. It'll be exectuted at least after 2000ms.


Please never do any of this inside any production code. Your future self will be thankful 🤓👀