Javascript 将两个回调组合成一个返回

所以我有这个代码：

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.getQuotence函数并返回一个对象：

{totalFee:108，totalFee货币：PHP}

现在，我添加了一个新函数，返回此对象：

{totalFee:10，totalFee货币：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" }]

---

我做错了什么？

您的callbacknull，响应不会等待这两个回调函数完成。您可以使用Promise和Promise.allobjs.then函数等待所有承诺完成并运行。

您的callbacknull，响应不会等待这两个回调函数完成。您可以使用Promise和Promise.allobjs.then函数等待所有承诺完成并运行。

尝试在Promise中包装两个报价调用，然后使用Promise.all等待两个报价调用完成，然后将结果返回回调

---

尝试在Promise中包装两个报价调用，然后使用Promise.all等待它们都完成，然后将结果返回回调

---

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

我们为您的案例提供了一些选项：回调地狱、异步库、承诺、异步/等待

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

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);
    });
  });
};

异步库： 您可以使用瀑布函数按顺序执行操作，如果顺序无关紧要，则可以并行执行

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);
  });
};

---

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

我们为您的案例提供了一些选项：回调地狱、异步库、承诺、异步/等待

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

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);
    });
  });
};

异步库： 您可以使用瀑布函数按顺序执行操作，如果顺序无关紧要，则可以并行执行

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);
  });
};

您还可以尝试使用和异步/等待语法

例如：

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));
};

您还可以尝试使用和异步/等待语法

例如：

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));
};