如何“;等待”;以便返回回调

How to "await" for a callback to return?

本文关键字：返回 回调 等待 如何      更新时间：2023-09-26

使用简单回调时，如以下示例中所示：

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

如何将函数更改为使用async/await？具体地说，假设"someEvent"保证只被调用一次，我希望函数测试是一个异步函数，在执行回调之前不会返回，例如：

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

async/await不是魔法。异步函数是一个可以为您打开Promise的函数，因此您需要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
}

没有一个简单的解决方案很烦人，包装return new Promise(...)很麻烦，但我发现使用util.promisify也可以（实际上它也有点像包装，只是看起来更好）。

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

上面的函数还没有返回任何内容。我们可以通过以下操作使其返回在callback中传递的response的Promise：

const util = require('util');
const asyncFunction = util.promisify(voidFunction);

现在我们实际上可以await，callback。

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

使用util.promisify 时的一些规则

  • callback必须是将成为promisify的函数的最后一个参数
  • 假定回调的格式必须为(err, res) => {...}

有趣的是，我们不需要专门写callback到底是什么。

async/await很神奇。您可以创建一个函数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');
}

args的数量是可变的。

const getprice = async () => {
return await new Promise((resolve, reject) => {
    binance.prices('NEOUSDT', (error, ticker) => {
        if (error) {
            reject(error)
        } else {
            resolve(ticker);
        }
    });
})}
router.get('/binanceapi/price', async function (req, res, next) {
res.send(await binanceAPI.getprice());});

您可以在没有回调的情况下实现这一点，使用promise async await而不是回调。在这里，我还展示了两种处理错误的方法

clickMe = async (value) => {
  
  // begin to wait till the message gets here;
  let {message, error} = await getMessage(value);
  
  // if error is not null
  if(error)
    return console.log('error occured ' + error);
   
  return console.log('message ' + message);
}
getMessage = (value) => {
  //returning a promise 
  return new Promise((resolve, reject) => {
  
    setTimeout(() => {
      // if passed value is 1 then it is a success
      if(value == 1){
        resolve({message: "**success**", error: null});
      }else if (value == 2){
        resolve({message: null, error: "**error**"});
      }
    }, 1000);
  
  });
}
clickWithTryCatch = async (value) => {
  try{
    //since promise reject in getMessage2 
    let message = await getMessage2(value);
    console.log('message is ' + message);
  }catch(e){
    //catching rejects from the promise
    console.log('error captured ' + e);
  }
}
getMessage2 = (value) => {
  return new Promise((resolve, reject) => {
  
    setTimeout(() => {
      if(value == 1)
        resolve('**success**');
      else if(value == 2)
        reject('**error**'); 
    }, 1000);
  
  });
}
<input type='button' value='click to trigger for a value' onclick='clickMe(1)' />
<br/>
<input type='button' value='click to trigger an error' onclick='clickMe(2)' />
<br/>
<input type='button' value='handling errors with try catch' onclick='clickWithTryCatch(1)'/>
<br/>
<input type='button' value='handling errors with try catch' onclick='clickWithTryCatch(2)'/>

定义一个返回promise的函数：

export const callbackf = (f, ...args) => new Promise((resolve, reject) => {
    f(...args, (error, data) => {
        if (error) {
            reject(error);
        } else {
            resolve(data);
        }
    });
});

在任何你需要的地方等待承诺。arg1、arg2、。。。是回调函数参数：

await callbackf(yourCallbackFunction, arg1, arg2, arg3, argN)
相关文章：