How can I wait In Node.js (JavaScript)? l need to pause for a period of time

The Question :

460 people think this question is useful

I’m developing a console script for personal needs. I need to be able to pause for an extended amount of time, but, from my research, Node.js has no way to stop as required. It’s getting hard to read users’ information after a period of time… I’ve seen some code out there, but I believe they have to have other code inside of them for them to work such as:

    setTimeout(function() {
    }, 3000);

However, I need everything after this line of code to execute after the period of time.

For example,

    // start of code
    console.log('Welcome to my console,');


    console.log('Blah blah blah blah extra-blah');
    // end of code

I’ve also seen things like

    yield sleep(2000);

But Node.js doesn’t recognize this.

How can I achieve this extended pause?

The Question Comments :
  • hows about you mark one of these people as correct answer 🙂
  • @Christopher Allen, Maybe not relevant, but does the job: require("child_process").execSync('php -r "sleep($argv[1]);" ' + seconds);
  • The node-sleep npm module might do the trick (however, I would only use it for debugging)

The Answer 1

229 people think this answer is useful

Best way to do this is to break your code into multiple functions, like this:

function function1() {
    // stuff you want to happen right away
    console.log('Welcome to My Console,');

function function2() {
    // all the stuff you want to happen after that pause
    console.log('Blah blah blah blah extra-blah');

// call the first chunk of code right away

// call the rest of the code and have it execute after 3 seconds
setTimeout(function2, 3000);

It’s similar to JohnnyHK‘s solution, but much neater and easier to extend.

The Answer 2

550 people think this answer is useful

A new answer to an old question. Today ( Jan 2017 June 2019) it is much easier. You can use the new async/await syntax. For example:

async function init() {
  await sleep(1000);

function sleep(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);

For using async/await out of the box without installing and plugins, you have to use node-v7 or node-v8, using the --harmony flag.

Update June 2019: By using the latest versions of NodeJS you can use it out of the box. No need to provide command line arguments. Even Google Chrome support it today.

Update May 2020: Soon you will be able to use the await syntax outside of an async function. In the top level like in this example

await sleep(1000)
function sleep(ms) {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);

The proposal is in stage 3. You can use it today by using webpack 5 (alpha),

More info:

The Answer 3

324 people think this answer is useful

The shortest solution without any dependencies:

await new Promise(resolve => setTimeout(resolve, 5000));

The Answer 4

156 people think this answer is useful

This is a simple blocking technique:

var waitTill = new Date(new Date().getTime() + seconds * 1000);
while(waitTill > new Date()){}

It’s blocking insofar as nothing else will happen in your script (like callbacks). But since this is a console script, maybe it is what you need!

The Answer 5

153 people think this answer is useful

Put the code that you want executed after the delay within the setTimeout callback:

console.log('Welcome to My Console,');
setTimeout(function() {
    console.log('Blah blah blah blah extra-blah');
}, 3000);

The Answer 6

72 people think this answer is useful

On Node 7.6.0 or higher

Node supports waiting natively:

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

then if you can use async functions:

await sleep(10000); // sleep for 10 seconds


sleep(10000).then(() => {
  // This will execute 10 seconds from now

On older Node versions (original answer)

I wanted an asynchronous sleep that worked in Windows & Linux, without hogging my CPU with a long while loop. I tried the sleep package but it wouldn’t install on my Windows box. I ended up using:

To install it, type:

npm install system-sleep

In your code,

var sleep = require('system-sleep');
sleep(10*1000); // sleep for 10 seconds

Works like a charm.

The Answer 7

64 people think this answer is useful

Simple and elegant sleep function using modern Javascript

function sleep(millis) {
    return new Promise(resolve => setTimeout(resolve, millis));

No dependencies, no callback hell; that’s it 🙂

Considering the example given in the question, this is how we would sleep between two console logs:

async function main() {
    await sleep(2000);


The “drawback” is that your main function now has to be async as well. But, considering you are already writing modern Javascript code, you are probably (or at least should be!) using async/await all over your code, so this is really not an issue. All modern browsers today support it.

Giving a little insight into the sleep function for those that are not used to async/await and fat arrow operators, this is the verbose way of writing it:

function sleep(millis) {
    return new Promise(function (resolve, reject) {
        setTimeout(function () { resolve(); }, millis);

Using the fat arrow operator, though, makes it even smaller (and more elegant).

The Answer 8

49 people think this answer is useful

You can use this

var sleep = require('sleep');
sleep.sleep(10); // sleep for ten seconds

The Answer 9

35 people think this answer is useful

This question is quite old, but recently V8 has added Generators which can accomplish what the OP requested. Generators are generally easiest to use for async interactions with the assistance of a library such as suspend or gen-run.

Here’s an example using suspend:

suspend(function* () {
    console.log('Welcome to My Console,');
    yield setTimeout(suspend.resume(), 10000); // 10 seconds pass..
    console.log('Blah blah blah blah extra-blah');

Related reading (by way of shameless self promotion): What’s the Big Deal with Generators?.

The Answer 10

24 people think this answer is useful

If you want to “code golf” you can make a shorter version of some of the other answers here:

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

But really the ideal answer in my opinion is to use Node’s util library and its promisify function, which is designed for exactly this sort of thing (making promise-based versions of previously existing non-promise-based stuff):

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

In either case you can then pause simply by using await to call your sleep function:

await sleep(1000); // sleep for 1s/1000ms

The Answer 11

21 people think this answer is useful

On Linux/nodejs this works for me:

const spawnSync = require(‘child_process’).spawnSync;

var sleep = spawnSync(‘sleep’, [1.5]);

It is blocking, but it is not a busy wait loop.

The time you specify is in seconds but can be a fraction. I don’t know if other OS’s have a similar command.

The Answer 12

15 people think this answer is useful

I’ve recently created simpler abstraction called wait.for to call async functions in sync mode (based on node-fibers). There is also a version based on upcoming ES6 Generators.

Using wait.for, you can call any standard nodejs async function, as if it were a sync function, without blocking node’s event loop.

You can code sequentially when you need it, which is, (I’m guessing) perfect to simplify your scripts for personal use.

using wait.for your code will be:

require('waitfor') a fiber..
console.log('Welcome to My Console,');
wait.miliseconds(10*1000); //defined in waitfor/paralell-tests.js - DOES NOT BLOCK
console.log('Blah blah blah blah extra-blah');

Also any async function can be called in Sync mode. Check the examples.

The Answer 13

8 people think this answer is useful

Since, javascript engine (v8) runs code based on sequence of events in event-queue, There is no strict that javascript exactly trigger the execution at after specified time. That is, when you set some seconds to execute the code later, triggering code is purely base on sequence in event queue. So triggering execution of code may take more than specified time.

So Node.js follows,


to run the code later instead setTimeout(). For example,

    console.log("This will be printed later");

The Answer 14

2 people think this answer is useful

With ES6 supporting Promises, we can use them without any third-party aid.

const sleep = (seconds) => {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, (seconds * 1000));

// We are not using `reject` anywhere, but it is good to
// stick to standard signature.

Then use it like this:

const waitThenDo(howLong, doWhat) => {
    return sleep(howLong).then(doWhat);

Note that the doWhat function becomes the resolve callback within the new Promise(...).

Also note that this is ASYNCHRONOUS sleep. It does not block the event loop. If you need blocking sleep, use this library which realizes blocking sleep with the help of C++ bindings. (Although the need for a blocking sleep in Node like async environments is rare.)

The Answer 15

0 people think this answer is useful
let co = require('co');
const sleep = ms => new Promise(res => setTimeout(res, ms));

co(function*() {
    console.log('Welcome to My Console,');
    yield sleep(3000);
    console.log('Blah blah blah blah extra-blah');

This code above is the side effect of the solving Javascript’s asynchronous callback hell problem. This is also the reason I think that makes Javascript a useful language in the backend. Actually this is the most exciting improvement introduced to modern Javascript in my opinion. To fully understand how it works, how generator works needs to be fully understood. The function keyword followed by a * is called a generator function in modern Javascript. The npm package co provided a runner function to run a generator.

Essentially generator function provided a way to pause the execution of a function with yield keyword, at the same time, yield in a generator function made it possible to exchange information between inside the generator and the caller. This provided a mechanism for the caller to extract data from a promise from an asynchronous call and to pass the resolved data back to the generator. Effectively, it makes an asynchronous call synchronous.

The Answer 16

0 people think this answer is useful

This is a moment.js flavored module based on the dirty blocking approach suggested by @atlex2. Use this only for testing.

const moment = require('moment');

let sleep = (secondsToSleep = 1) => {
    let sleepUntill = moment().add(secondsToSleep, 'seconds');
    while(moment().isBefore(sleepUntill)) { /* block the process */ }

module.exports = sleep;

The Answer 17

-1 people think this answer is useful

simple we are going to wait for 5 seconds for some event to happen (that would be indicated by done variable set to true somewhere else in the code) or when timeout expires that we will check every 100ms

    var timeout=5000; //will wait for 5 seconds or untildone
    var scope = this; //bind this to scope variable
    (function() {
        if (timeout<=0 || scope.done) //timeout expired or done
            scope.callback();//some function to call after we are done
            setTimeout(arguments.callee,100) //call itself again until done
            timeout -= 100;

The Answer 18

-1 people think this answer is useful

For some people, the accepted answer is not working, I found this other answer and it is working for me: How can I pass a parameter to a setTimeout() callback?

var hello = "Hello World";
setTimeout(alert, 1000, hello); 

‘hello’ is the parameter being passed, you can pass all the parameters after the timeout time. Thanks to @Fabio Phms for the answer.

The Answer 19

-1 people think this answer is useful
function doThen(conditional,then,timer) {
    var timer = timer || 1;
    var interval = setInterval(function(){
        if(conditional()) {
    }, timer);

Example usage:

var counter = 1;
    function() {
        return counter == 1000;
    function() {
        console.log("Counter hit 1000"); // 1000 repeats later

The Answer 20

-2 people think this answer is useful

If you just need to suspend for testing purpose you current thread execution try this:

function longExecFunc(callback, count) {

    for (var j = 0; j < count; j++) {
        for (var i = 1; i < (1 << 30); i++) {
            var q = Math.sqrt(1 << 30);
longExecFunc(() => { console.log('done!')}, 5); //5, 6 ... whatever. Higher -- longer

The Answer 21

-3 people think this answer is useful

The other answers are great but I thought I’d take a different tact.

If all you are really looking for is to slow down a specific file in linux:

 rm slowfile; mkfifo slowfile; perl -e 'select STDOUT; $| = 1; while(<>) {print $_; sleep(1) if (($ii++ % 5) == 0); }' myfile > slowfile  &amp;

node myprog slowfile

This will sleep 1 sec every five lines. The node program will go as slow as the writer. If it is doing other things they will continue at normal speed.

The mkfifo creates a first-in-first-out pipe. It’s what makes this work. The perl line will write as fast as you want. The $|=1 says don’t buffer the output.

The Answer 22

-3 people think this answer is useful

Instead of doing all these setTimeout, sleep and many other things, it’s better to use

const delay = require('delay');
await delay(2000); // will wait for 2 seconds before executing next line of code

The Answer 23

-4 people think this answer is useful

I put together, after having read the answers in this question, a simple function which can also do a callback, if you need that:

function waitFor(ms, cb) {
  var waitTill = new Date(new Date().getTime() + ms);
  while(waitTill > new Date()){};
  if (cb) {
  } else {
   return true

The Answer 24

-5 people think this answer is useful

For more info on

yield sleep(2000); 

you should check Redux-Saga. But it is specific to your choice of Redux as your model framework (although strictly not necessary).

Add a Comment