difference between 'util.promisify(setTimeout)' and 'ms => new Promise(resolve => setTimeout(resolve, ms))'

Question

Environment: node 8.11.x I want use async/await for sleep a while.

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

This works.

const sleep = util.promisify(setTimeout)
await sleep(5000)

It cause a exception: TypeError: "callback" argument must be a function. setTimeout The document note: This method has a custom variant for promises that is available using util.promisify()

So what's the difference?

Answer 1

promisify is expects a function that has final argument that is the callback.

In other a words it wants a function that looks like:

function takesACallback(str, Fn) {
    Fn(null, "got: ", str)
    // or with an error:
    // Fn(error)
}

Of course setTimout is the opposite. The argument you want to pass in is the last argument. So when you try to call the promisifyd function and pass in an argument, it will take that argument -- the delay-- and try to call it like a function. Of course that's an error.

For entertainment (and slight educational) purposes only, you can pass in a function that reverses the arguments and it will work:

let util = require('util')

let pause = util.promisify((a, f) => setTimeout(f, a))
pause(2000)
.then(() => console.log("done"))

Now the final argument of the function you passed to promisify expects function. But the asyn/await method is so much nicer…

Answer 2

You know that this right here works:

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

;(async () => {

  const ts = Date.now()

  await sleep(5000)

  console.log(Date.now()-ts)

})();

This works fine, why not go with it and use it???

Answer 3

This can be a one-liner: await promisify(setTimeout)(1000).

It works because setTimeout has a custom variant for promisify. It does work with node 8.11.

nvm install 8.11 && nvm use 8.11
node <<HEREDOC
  (async () => {
    // const start = Date.now();
    await require('util').promisify(setTimeout)(5000);
    // console.log(Date.now() - start);
  })()
HEREDOC

Answer 4

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

Is the essence of the implementation of util.promisify(setTimeout), but there are additional features to the promisify implementation:

• it takes an optional value argument that is returned as the value of the promise

setTimeoutPromisify(10, 'foo bar').then(value => console.log(value)) // logs "foo bar"
console.log(await setTimeoutPromisify(10, 'foo bar')) // logs "foo bar"

• it takes an (optional) options argument that
  • lets you specify an AbortController signal to cancel the timeout
  • lets you choose whether or not to keep a ref, which if set to false, means the program will exit before the timeout finishes if nothing else is happening

const controller = new AbortController();
const signal = ac.signal;

setTimeoutPromisify(1000, 'foo bar', { signal, ref: true })
  .then(console.log)
  .catch((err) => {
    if (err.name === 'AbortError')
      console.log('The timeout was aborted');
  })

controller.abort()

For more information see https://nodejs.org/api/timers.html

The implementation in node 16 is below:

function setTimeout(after, value, options = {}) {
  const args = value !== undefined ? [value] : value;
  if (options == null || typeof options !== 'object') {
    return PromiseReject(
      new ERR_INVALID_ARG_TYPE(
        'options',
        'Object',
        options));
  }
  const { signal, ref = true } = options;
  try {
    validateAbortSignal(signal, 'options.signal');
  } catch (err) {
    return PromiseReject(err);
  }
  if (typeof ref !== 'boolean') {
    return PromiseReject(
      new ERR_INVALID_ARG_TYPE(
        'options.ref',
        'boolean',
        ref));
  }

  if (signal && signal.aborted) {
    return PromiseReject(new AbortError());
  }
  let oncancel;
  const ret = new Promise((resolve, reject) => {
    const timeout = new Timeout(resolve, after, args, false, true);
    if (!ref) timeout.unref();
    insert(timeout, timeout._idleTimeout);
    if (signal) {
      oncancel = FunctionPrototypeBind(cancelListenerHandler,
                                       timeout, clearTimeout, reject);
      signal.addEventListener('abort', oncancel);
    }
  });
  return oncancel !== undefined ?
    PromisePrototypeFinally(
      ret,
      () => signal.removeEventListener('abort', oncancel)) : ret;
}