将两个回调合并为一个 return

Question

所以我有这个代码：

module.exports.getEstimate = (event, context, callback) => {
 var data = JSON.parse(event.body);

 lalamove.getQuotation(data ,context, function(err, llm_data){
  callback(null,llm_data)
 });
};

所以它调用lalamove.getQuotation函数和returns一个对象：

{ "totalFee": "108", "totalFeeCurrency": "PHP" }

现在，我添加了一个新函数，即 returns 这个对象：

{ "totalFee": "10", "totalFeeCurrency": "PHP" }

来自不同的函数，所以我想我应该将它们放在一个数组中，然后我会调用回调但它不起作用，这就是我尝试过的

module.exports.getEstimate = (event, context, callback) => {
var data = JSON.parse(event.body);
var response = []

lalamove.getQuotation(data ,context, function(err, llm_data){
  const llm_obj = { "lalamove": llm_data }
  response.push(llm_obj);
});

inhouse.getQuotation(data ,context, function(err, ih_data){
  const ih_obj = {"inhouse": ih_data }
  response.push(ih_obj);
});

callback(null,response);
};

我想要的响应是这样的：

["lalamove": { "totalFee": "108", "totalFeeCurrency": "PHP" },
"inhouse": { "totalFee": "10", "totalFeeCurrency": "PHP" }]

我做错了什么？

Answer 1

您的 callback(null,response) 不会等待这两个回调函数完成。您可以使用 Promise 并使用 Promise.all(objs).then(function) 等待所有承诺完成并运行.

Answer 2

尝试在 Promise 中包装两个报价调用，然后利用 Promise.all 等待它们都完成，然后 return 结果到 callback

module.exports.getEstimate = (event, context, callback) => {
    let data = JSON.parse(event.body);

    // wrap quotation calls in `Promise`
    Promise.all([
        new Promise(resolve => lalamove.getQuotation(data, context, (err, lalamove) => resolve({ lalamove }))),
        new Promise(resolve => inhouse.getQuotation (data, context, (err, inhouse ) => resolve({ inhouse  }))),
    ]).then(response => {
        // return the result back to `callback`
        callback(null, response);
    })
};

Answer 3

欢迎来到 World 的 Javascript 世界 - 回调地狱。

我们为您的情况提供了一些选项：回调地狱、异步库、Promise、async/await...

回调地狱：在回调中调用异步函数

module.exports.getEstimate = (event, context, callback) => {
  var data = JSON.parse(event.body);
  var response = []

  lalamove.getQuotation(data, context, function (err, llm_data) {
    const llm_obj = { "lalamove": llm_data }
    response.push(llm_obj);

    // lalamove.getQuotation done!
    // call next action
    inhouse.getQuotation(data, context, function (err, ih_data) {
      const ih_obj = { "inhouse": ih_data }
      response.push(ih_obj);

      // inhouse.getQuotation done!
      // call the last action
      callback(null, response);
    });
  });
};

异步库：async 您可以使用 waterfall 函数按顺序执行操作，如果顺序无关紧要，则可以使用 parallel。

module.exports.getEstimate = (event, context, callback) => {
  var data = JSON.parse(event.body);
  var response = []

  async.parallel([
    function (next) {
      lalamove.getQuotation(data, context, function (err, llm_data) {
        // TODO: check err object
        const llm_obj = { "lalamove": llm_data }
        response.push(llm_obj);

        // lalamove.getQuotation done!
        // do next action
        next();
      });
    },
    function (next) {
      inhouse.getQuotation(data, context, function (err, ih_data) {
        const ih_obj = { "inhouse": ih_data }
        response.push(ih_obj);

        // inhouse.getQuotation done!
        // do next action
        next()
      });
    }
  ], function (err) {
    // TODO: check err object
    // call the last action
    callback(null, response);
  });
};

Answer 4

您也可以尝试使用 util.promisify 和 async / await 语法。

例如：

const util = require("util");

module.exports.getEstimate = async (event, context, callback) => {
    let data = JSON.parse(event.body);
    try { 
        let response = await Promise.all([ util.promisify(lalamove.getQuotation)(data, context), 
                                           util.promisify(inhouse.getQuotation)(data, context) ]);
        callback(null, response);
    } catch (err) {
        callback(err);
    }
};

我们也可以做类似的事情，但没有异步/等待：

const util = require("util");

const getEstimate = (event, context, callback) => {
    let data = JSON.parse(event.body);
    Promise.all([util.promisify(lalamove.getQuotation)(data, context), 
                util.promisify(inhouse.getQuotation)(data, context)])
        .then(response => callback(null, response))
        .catch(err => callback(err));
};

将两个回调合并为一个 return

Combine two callbacks into one return

javascript

node.js

serverless-framework