Combination of async function + await + setTimeout

Question

I am trying to use the new async features and I hope solving my problem will help others in the future. This is my code which is working:

  async function asyncGenerator() {
    // other code
    while (goOn) {
      // other code
      var fileList = await listFiles(nextPageToken);
      var parents = await requestParents(fileList);
      // other code
    }
    // other code
  }

  function listFiles(token) {
    return gapi.client.drive.files.list({
      'maxResults': sizeResults,
      'pageToken': token,
      'q': query
    });
  }

The problem is, that my while loop runs too fast and the script sends too many requests per second to the google API. Therefore I would like to build a sleep function which delays the request. Thus I could also use this function to delay other requests. If there is another way to delay the request, please let me know.

Anyway, this is my new code which does not work. The response of the request is returned to the anonymous async function within the setTimeout, but I just do not know how I can return the response to the sleep function resp. to the initial asyncGenerator function.

  async function asyncGenerator() {
    // other code
    while (goOn) {
      // other code
      var fileList = await sleep(listFiles, nextPageToken);
      var parents = await requestParents(fileList);
      // other code
    }
    // other code
  }

  function listFiles(token) {
    return gapi.client.drive.files.list({
      'maxResults': sizeResults,
      'pageToken': token,
      'q': query
    });
  }

  async function sleep(fn, par) {
    return await setTimeout(async function() {
      await fn(par);
    }, 3000, fn, par);
  }

I have already tried some options: storing the response in a global variable and return it from the sleep function, callback within the anonymous function, etc.

Osswald

See also https://mcmap.net/q/36107/-what-is-the-javascript-version-of-sleep/327074 – Fashion

Answer 1

Your sleep function does not work because setTimeout does not (yet?) return a promise that could be awaited. You will need to promisify it manually:

function timeout(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
async function sleep(fn, ...args) {
    await timeout(3000);
    return fn(...args);
}

Btw, to slow down your loop you probably don't want to use a sleep function that takes a callback and defers it like this. I recommend:

while (goOn) {
  // other code
  var [parents] = await Promise.all([
      listFiles(nextPageToken).then(requestParents),
      timeout(5000)
  ]);
  // other code
}

which lets the computation of parents take at least 5 seconds.

Frasier

what does the notation of var [parents] represent? I haven't seen it before and it's a difficult thing to google – Variance

@NateUsher It's array destructuring – Frasier

@tinkerr "timeout needs to be declared async if it needs to be awaited" - Nope. A function only needs to return a promise that can be awaited (or actually, a thenable is enough). How it achieves that is up to the implementation of the function, it does not need to be an async function. – Frasier

I thought async/await was replacing all uses of Promises? Is there a way to use async/await and setTimeout without Promises? – Floccule

@Floccule No, async/await is based on promises. The only thing it replaces are then calls. – Frasier

function timeout(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } is not exactly the same as setTimeout behaviour on it own if you wait "ms" time after you call the function and before you use the promise value (for example register with a then, you might get the result immediately which is something one might not expect ... – Magisterial

@Magisterial Not sure what you mean by "not exactly the same", or how that would matter. And no, when you register a then callback, you never get the result immediately, it always is asynchronous. – Frasier

you can await setTimeout in Node.js 15, update your answer – Apartment

In ` return new Promise(resolve => setTimeout(resolve, ms));` -- what is the resolve argument? – Davison

@Davison developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…. It's the function given to you by the promise constructor that lets you resolve the promise by calling it – Frasier

@Floccule In fact, async/await is just a syntactic sugar for promises. This makes me think that we should know how promises work under the hood. – Dishonesty

Promise.all is evaluated in parallel, not sequentially. So this will kind of break if you try to run it in a loop – Imitation

@Imitation The loop is meant to be sequential. All the Promise.all does is to ensure each iteration takes at least 5s. – Frasier

@Variance here is a direct Mozilla link about var [parents] Destructuring Assignment – Wongawonga

setTimeout returns an ID that is meant to be used with clearTimeout in order to stop the timer. It's not meant to return a Promise. – Pruritus

@Pruritus If the API was designed today, the function would accept a millisecond count and an optional abort signal, and return a promise. See for example setTimeout from timers/promises of nodejs. – Frasier

I think at this point the "correct" answer would be https://mcmap.net/q/63429/-combination-of-async-function-await-settimeout since that package handles the timeout function. – Praetor

@Praetor In nodejs, yes, use node:timers/promises. In the browser and other environments, still no :-( – Frasier

Answer 2

The quick one-liner, inline way

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

Polyp

what does it mean when you guys use "resolve" x 2 times in the same line? Like: await new Promise(resolve => setTimeout(resolve, 1000)); does it ref. to itself or what? I would do something like this instead: function myFunc(){}; await new Promise(resolve => setTimeout(myFunc, 1000)); – Poplin

@Poplin that would block forever because the promise never resolves. – Polyp

@Poplin You can expand the one-liner above to this (more verbose) version, which hopefully makes it obvious why resolve appears twice. If it's still confusing, take a look at the MDN docs for Promise. – Massey

@Poplin It could also be represented like this: await new Promise((resolve, reject) => setTimeout(resolve, 1000));. So, resolve and reject are callbacks exposed when you create a Promise. You're simply telling setTimeout to execute resolve(). – Aesir

this fail with eslint 8, no-promise-executor-return – Babblement

you deserve a Nobel Prize – Balmacaan

So I didn't quite understand how to use this one liner at first, but if I'm not mistaken, it basically allows me to add a timeout on a single line BEFORE a for loop so I don't need to wrap anything? It appeared to work that way, I just want to make sure it won't fail on me later. I basically needed a 10 second delay before a for loop started and so I dropped this above my for loop and changed the 1000 to 10000 and it seemed to work perfectly. Anything I'm missing? – Inellineloquent

@Joe, it's due to the arrow function which "implicitly returns". So, it should not result in the ESLint error with the following: await new Promise(resolve => { setTimeout(resolve, 1000); });. On the subject: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… – Mohamed

Answer 3

Since Node 7.6, you can combine the functions promisify function from the utils module with setTimeout() .

Node.js

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

Javascript

const sleep = m => new Promise(r => setTimeout(r, m))

Usage

(async () => {
    console.time("Slept for")
    await sleep(3000)
    console.timeEnd("Slept for")
})()

Riffle

In nodeJS await require('util').promisify(setTimeout)(3000) can also be achieved without require by: await setTimeout[Object.getOwnPropertySymbols(setTimeout)[0]](3000) – Lilias

Interesting @Shl. I think it is less readable than my solution though. If people disagree I can add it to the solution? – Riffle

Nice, love the conciseness of the new native util promisify. – Salaried

The require version is clearly much better than the getOwnPropertySymbols version... if it ain't broke...! – Mountebank

Hey there @Harry. It appears you incorporated the one liner from FlavorScape's answer in your own answer. I don't want to presume of your intentions, but that isn't really fair to them. Could you rollback your edit? Right now it looks a bit like plagiarism.. – Estimate

@FélixGagnon-Grenier why should he roll back, let him keep his plagiarism. Good ideas should be copied. – Valiancy

@Valiancy Not on Stack Overflow. – Estimate

@FélixGagnon-Grenier He can keep it on my Stack Overflow. – Valiancy

@FélixGagnon-Grenier he should be called out for plagiarism, but let him keep it. Maybe he can make a better answer with it than FlavorScape , maybe not. Let the votes decide. – Valiancy

I've removed the one-liner as the answer is right below, however I have seen many popular answers update their answers to include other new answers as most readers don't bother looking past the first few responses. – Riffle

You should remember that async IIFE will wait only for functions inside it: same-level code will not be paused: ~~~ console.log('pre'); (async () => { console.log('start') console.time("Slept for") await sleep(3000) console.timeEnd("Slept for") console.log('end') })() console.log('post') ~~~ will print: pre,start,post,end – Lateritious

Also to be fair, I think FlavourScape probably adapted my answer to create his anyway :) – Riffle

Answer 4

Timers Promises API

await setTimeout finally arrived with Node.js 16, removing the need to use util.promisify():

import { setTimeout } from 'timers/promises';

(async () => {
  const result = await setTimeout(2000, 'resolved')
  // Executed after 2 seconds
  console.log(result); // "resolved"
})()

Official Node.js docs: Timers Promises API (library already built in Node)

Calais

100% this is my goto answer. I always find this article when I forget what the import is. This should be the accepted answer now. – Praetor

Answer 5

setTimeout is not an async function, so you can't use it with ES7 async-await. But you could implement your sleep function using ES6 Promise:

function sleep (fn, par) {
  return new Promise((resolve) => {
    // wait 3s before calling fn(par)
    setTimeout(() => resolve(fn(par)), 3000)
  })
}

Then you'll be able to use this new sleep function with ES7 async-await:

var fileList = await sleep(listFiles, nextPageToken)

Please, note that I'm only answering your question about combining ES7 async/await with setTimeout, though it may not help solve your problem with sending too many requests per second.

---

Update: Modern node.js versions has a buid-in async timeout implementation, accessible via util.promisify helper:

const {promisify} = require('util');
const setTimeoutAsync = promisify(setTimeout);

Cristobal

You shouldn't do that, when fn throws the errror would not be caught. – Frasier

@Frasier I think it bubbles up to the new Promise where you can sleep.catch it. – Eniwetok

@Dodekeract No, it's in an asynchronous setTimeout callback and the new Promise callback has been done for long. It will bubble to the global context and be thrown as an unhandled exception. – Frasier

> problem with sending too many requests per second. You want to use "debounce" perhaps to prevent things like UI firing too many ruquests. – Polyp

settimeout is async, read here:developer.mozilla.org/en-US/docs/Web/API/setTimeout – Killen

Answer 6

If you would like to use the same kind of syntax as setTimeout you can write a helper function like this:

const setAsyncTimeout = (cb, timeout = 0) => new Promise(resolve => {
    setTimeout(() => {
        cb();
        resolve();
    }, timeout);
});

You can then call it like so:

const doStuffAsync = async () => {
    await setAsyncTimeout(() => {
        // Do stuff
    }, 1000);

    await setAsyncTimeout(() => {
        // Do more stuff
    }, 500);

    await setAsyncTimeout(() => {
        // Do even more stuff
    }, 2000);
};

doStuffAsync();

I made a gist: https://gist.github.com/DaveBitter/f44889a2a52ad16b6a5129c39444bb57

Kurr

a function name like delayRun would make more sense here, since it will delay the running of the callback function by X seconds. Not a very await-ey example, IMO. – Guttle

Answer 7

I leave this code snippet here for someone who wants to fetch API call (e.g. get clients) with setTimeout:

const { data } = await new Promise(resolve => setTimeout(resolve, 250)).then(() => getClientsService())
setName(data.name || '')
setEmail(data.email || '')

Hollinger

This should be the accepted answer. – Tunicle

Answer 8

await new Promise(resolve => setTimeout(() => { resolve({ data: 'your return data'}) }, 1000))

Cronus

Answer 9

var testAwait = function () {
    var promise = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Inside test await');
        }, 1000);
    });
    return promise;
}

var asyncFunction = async function() {
    await testAwait().then((data) => {
        console.log(data);
    })
    return 'hello asyncFunction';
}

asyncFunction().then((data) => {
    console.log(data);
});

//Inside test await
//hello asyncFunction

Wolverine

Answer 10

This is my version with nodejs now in 2020 in AWS labdas

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

async function f1 (some){
...
}

async function f2 (thing){
...
}

module.exports.someFunction = async event => {
    ...
    await f1(some)
    await sleep(5000)
    await f2(thing)
    ...
}

Archipelago

What is promisify doing to setTimeout for your custom sleep function that causes it to no longer need a function as the first argument? For example, if you run setTimeout(5000); (not having a function as the first argument) you get Uncaught TypeError [ERR_INVALID_CALLBACK]: Callback must be a function. Received 5000. – Kriskrischer

Answer 11

await setTimeout(()=>{}, 200);

Will work if your Node version is 15 and above.

Chromolithograph

Doesn't work, even in Node ^16. Ref comments in https://mcmap.net/q/63429/-combination-of-async-function-await-settimeout – Vanadium

Answer 12

With the marked answer I had a lint error [no-promise-executor-return] so I found here the corrected version, using curly brackets in order to make explicit the intention of not returning anything:

const timeout = (ms) =>
  new Promise(resolve => {
    setTimeout(resolve, ms)
  })

Topo

Answer 13

I would like to point out a robust extension to Promise.all. A rather elegant solution that works with one promise to be time-limited only is to race the promise with a timeout (such as new Promise((resolve) => setTimeout(resolve, timeout))).

await new Promise.race([myPromise, timeoutPromise])

will continue as soon as one of the promises finished. myPromise then can internally await a different timeout, or simply make use of Promise.all

const timeout = ms => new Promise((resolve) => setTimeout(resolve, ms));
await Promise.race([
    Promise.all([myPromise, timeout(500)]),
    timeout(5000)
]);

The result is an asynchronous call that does not run more often than twice a second, with a timeout of 5 seconds in case of some (network/server?) error.

Moreover, you can make this very versatile and customizable function as such:

function callWithTimeout(promise, msTimeout=5000, throws=false) {
    const timeout = ms => new Promise((resolve, reject) =>
        setTimeout(throws ? reject : resolve, ms));
    await Promise.race([
        //depends whether you want to wait there or just pass the promise itself
        Promise.all([promise, timeout(500)]), 
        timeout(msTimeout)
    ]);
}
    

Which ultimately lets you customize the timeout time and the whether the promise should succeed or throw on timeout. Having such robust general implementation can save you a lot of pain in the future. You can also set a string instead of boolean as throws and bind this variable to the reject for custom error message: reject.bind(undefined, throws)

Note that you should not pass your promise with await:

const myPromise = async x => x;
//will never time out and not because myPromise will finish immediatelly
callWithTimeout(await myPromise(), 2000, true); 
//will possibly timeout after 2 sec with an exception, or finish 
callWithTimeout(myPromise(), 2000, true); 

Incudes

Answer 14

Made a util inspired from Dave's answer

Basically passed in a done callback to call when the operation is finished.

// Function to timeout if a request is taking too long
const setAsyncTimeout = (cb, timeout = 0) => new Promise((resolve, reject) => {
  cb(resolve);
  setTimeout(() => reject('Request is taking too long to response'), timeout);
});

This is how I use it:

try {
  await setAsyncTimeout(async done => {
    const requestOne = await someService.post(configs);
    const requestTwo = await someService.get(configs);
    const requestThree = await someService.post(configs);
    done();
  }, 5000); // 5 seconds max for this set of operations
}
catch (err) {
  console.error('[Timeout] Unable to complete the operation.', err);
}

Ladysmith

Answer 15

The following code works in Chrome and Firefox and maybe other browsers.

function timeout(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
async function sleep(fn, ...args) {
    await timeout(3000);
    return fn(...args);
}

But in Internet Explorer I get a Syntax Error for the "(resolve **=>** setTimeout..."

Fill

Answer 16

How to Log all the responses at once?

async function sayHello(name) {
  let greet = `Hey! ${name} very nice to meet you bud.`;
  setTimeout(() => {
    return {
      greet,
      createdAt: new Date(),
    };
  }, 1000);
}

const response1 = async () => await sayHello("sounish");
const response2 = async () => await sayHello("alex");
const response3 = async () => await sayHello("bill");

async function getData() {
  const data1 = await sayHello("sounish");
  const data2 = await sayHello("alex");
  const data3 = await sayHello("bill");
  return { data1, data2, data3 };
}

Promise.all([sayHello("sounish"), sayHello("alex"), sayHello("bill")]).then(
  (allResponses) => {
    console.log({ allResponses });
  }
);

getData().then((allData) => {
  console.log({ allData });
});

Chlorate

Answer 17

I wanted to solve what I think is a related problem: the ability to auto-refresh a page every 30 seconds, but also live update some timers on-screen once a second and I wanted to make sure these 2 things didn't conflict. My google searches led me to your question here, so I thought I would share what I came up with in case it helps others:

class Elapsed
{
    constructor()
    {
        this.start = performance.now()
    }
    elapsed_seconds( seconds )
    {
        let elapsed_seconds = ( performance.now() - this.start ) * 0.001
        return elapsed_seconds >= seconds
    }
}

async function sleep( seconds )
{
    let promise = new Promise(( resolve, _ ) => {
        setTimeout( () => resolve(), seconds * 1000 )
    })
    await promise
}

async function refresh()
{
    // do something
    return new Elapsed()
}

async function auto_refresh()
{
    while( true )
    {
        let last_refresh = await refresh()
        while( !last_refresh.elapsed_seconds( 30 ))
        {
            await update_counters()
            await sleep( 1 )
        }
    }
}

Grievous

Answer 18

setTimeout(async () => {
   var x = await asyncFunction(); 
}, 5000)

Dato

Answer needs supporting information Your answer could be improved with additional supporting information. Please edit to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers in the help center. – Hex

Answer 19

This is a quicker fix in one-liner.

Hope this will help.

// WAIT FOR 200 MILISECONDS TO GET DATA //
await setTimeout(()=>{}, 200);

Mcphee

Doesn't work. This: await setTimeout(()=>{console.log('first')}, 200); console.log ('second') prints second then first – Valiancy

@Valiancy that is the point yes. This is a non blocking solution where code outside the function can continue to execute while a "blocking operation" is completed outside the main program flow. Although the syntax you and Rommy and Mohamad have provided isn't strictly correct due to the requirement for an await to be rapped in an async function (might be a fairly recent addition), also I'm using node.js. This is my tweaked solution. var test = async () => { await setTimeout(()=>{console.log('first')}, 1000); console.log ('second') } I've extended the timeout to show it's usefulness. – Unclog