如何“等待”回调返回？

Question

使用以下示例中的简单回调时：

test() {
  api.on( 'someEvent', function( response ) {
    return response;
  });
}

如何将函数更改为使用异步/等待？具体地说，假设某个事件保证被调用一次并且只有一次，我希望函数测试是一个异步函数，直到执行回调才返回，例如：

async test() {
  return await api.on( 'someEvent' );
}

Answer 1

异步/等待是神奇的。您可以创建一个函数asPromise，以处理此类情况：

function asPromise(context, callbackFunction, ...args) {
    return new Promise((resolve, reject) => {
        args.push((err, data) => {
            if (err) {
                reject(err);
            } else {
                resolve(data);
            }
        });
        if (context) {
            callbackFunction.call(context, ...args);
        } else {
            callbackFunction(...args);
        }
    });
}

然后在你想要的时候使用它：

async test() {
    return await this.asPromise(this, api.on, 'someEvent');
}

arg的数量是可变的。

Answer 2

很烦人的是，没有一个简单的解决方案，包装返回新的Promise（...）是模糊的，但是我已经找到了一个可以使用util.promisify的解决方案（实际上它也做了相同的包装，只是看起来更好）。

function voidFunction(someArgs, callback) {
  api.onActionwhichTakesTime(someMoreArgs, (response_we_need) => {
    callback(null, response_we_need);
  });
}

上述函数尚未返回任何内容。我们可以通过执行以下操作使其返回传入回调的响应的promise：

const util = require('util');

const asyncFunction = util.promisify(voidFunction);

现在我们可以真正地等待回调。

async function test() {
  return await asyncFunction(args);
}

使用util.promisify时的一些规则

• 回调必须是将被promisify
的函数的最后一个参数
• 假定的回调必须以（err， res）=

有趣的是，我们不需要专门编写回调实际上是什么。

Answer 3

async/wait不是魔术。异步函数是一个可以为您打开Promises的函数，因此您需要api.on（）返回Promise才能正常工作。像这样的东西：

function apiOn(event) {
  return new Promise(resolve => {
    api.on(event, response => resolve(response));
  });
}

然后

async function test() {
  return await apiOn( 'someEvent' ); // await is actually optional here
                                      // you'd return a Promise either way.
}

但这也是一个谎言，因为异步函数本身也会返回promise，因此您实际上不会从test（）中获取值，而是获取一个值的promise，您可以这样使用：

async function whatever() {
  // snip
  const response = await test();
  // use response here
  // snip
}