Is using async in setTimeout valid?

Question

I had a asynchronous function in Javascript and I added setTimeout to it. The code looks like this:

let timer;
clearTimeout(timer);
timer =setTimeout(() => {
(async() => {
    await this._doSomething();
})();
}, 2000);

The purpose of setTimeout is to add 2 seconds before function will be run. It is to be sure that user stopped typing.

Should I remove async/await from this function now, since setTimeout is asynchronous anyway?

Fescennine

"The code looks like that" Unlikely, and that's why you shouldn't remove async and await. It makes no sense in this example, but that doesn't mean it's pointless in (the) real code. – Adhamh

It's a bit unclear what you are asking here exactly. How is the piece of code supposed to work and how might removing async and await change that? Without a clear question that has an actual answer to it, you are just getting very broad and opinionated advice. – Boehmer

I have edited question to make it more clear what I am trying to achive. – Fescennine

Answer 1

setTimeout adds a delay before a function call, whereas async/await is syntactic sugar ontop of promises, a way to chain code to run after a call completes, so they're different.

setTimeout has terrible error-handling characteristics, so I recommend the following in all code:

let wait = ms => new Promise(resolve => setTimeout(resolve, ms));

and then never call setTimeout directly again.

Your code now becomes:

let foo = async () => {
  await wait(2000);
  await this._doSomething();
}

except foo waits for doSomething to finish. This is usually desirable, but without context it's hard to know what you want. If you meant to run doSomething in parallel with other code, I recommend:

async () => { await Promise.all([foo(), this._otherCode()]); };

to join and capture errors in the same place.

If you truly meant to fire and forget _doSomething and not wait for it, you can lose the await, but you should try/catch errors:

async () => {
  let spinoff = async () => { try { await foo(); } catch (e) { console.log(e); } };
  spinoff(); // no await!
}

But I don't recommend that pattern, as it's subtle and can be easy to miss.

Gardant