Javascript 如何处理NodeJ中的多个回调返回值？_Javascript_Node.js

Javascript 如何处理NodeJ中的多个回调返回值？

javascript node.js

Javascript 如何处理NodeJ中的多个回调返回值？,javascript,node.js,Javascript,Node.js,我试图根据if条件中的回调结果执行sql查询，但我无法编写代码。因此，请在代码中提供som信息 app.get('/resell-property', function(req, res) { var data = {} data.unit_price_id = 1; function callback(error, result) { if (result.count == 0) { ret

我试图根据if条件中的回调结果执行sql查询，但我无法编写代码。因此，请在代码中提供som信息

app.get('/resell-property', function(req, res) {
        var data = {}
        data.unit_price_id = 1;
        function callback(error, result) {
            if (result.count == 0) {
                return hp_property_sell_request.create(data)
            }
            else if (result.count > 0) {
                return hp_unit_price.findAll({
                    where: {
                        unit_price_id: data.unit_price_id,
                        hp_property_id: data.property_id,
                        hp_unit_details_id: data.unit_details_id
                    }
                })
            }
        }


        hp_property_sell_request.findAndCountAll({
            where: {
                unit_price_id: data.unit_price_id
            }
        }).then(function (result) {
            if (result) {
                callback(null, result);
            }
        });


    });

在这种情况下，如何编写的回调

hp_property_sell_request.create(data) ,hp_unit_price.findAll({
                    where: {
                        unit_price_id: data.unit_price_id,
                        hp_property_id: data.property_id,
                        hp_unit_details_id: data.unit_details_id
                    }
                })

在再次返回结果之后，我必须处理回调并执行此查询

if(result.request_id){
               return hp_unit_price.findAll({
                    where:{
                        unit_price_id:result.unit_price_id,
                        hp_property_id:result.property_id,
                        hp_unit_details_id:result.unit_details_id
                    }
                }).then(function (result){

                    if(result.is_resale_unit==0 && result.sold_out==0){
                        return Sequelize.query('UPDATE hp_unit_price SET resale_unit_status=1 WHERE hp_unit_details_id='+result.unit_details_id+' and  hp_property_id='+result.property_id)
                    }

                })
            }

我建议您使用来解决这个问题。如果您需要所有请求的所有结果，当它们全部完成时，

Promise.all（）

将为您提供这些结果。您的基本配置可能如下所示：

var req1 = new Promise(function(res, rej){
    var req = new XMLHttpRequest()
    …
    req.addEventListener('load', function (e) {
        res(e);
    })

var req2 = //similar to the above

Promise.all([req1, req2, …]).then(function(values){
  //all requests are done here and you can do your stuff
});

您还可以使用新的fetch api，它创建如下承诺：

var req1 = fetch(…);
var req2 = fetch(…);
Promise.all([req1, re2, …]).then(…);

我建议您使用来解决这个问题。如果您需要所有请求的所有结果，当它们全部完成时，

Promise.all（）

将为您提供这些结果。您的基本配置可能如下所示：

var req1 = new Promise(function(res, rej){
    var req = new XMLHttpRequest()
    …
    req.addEventListener('load', function (e) {
        res(e);
    })

var req2 = //similar to the above

Promise.all([req1, req2, …]).then(function(values){
  //all requests are done here and you can do your stuff
});

您还可以使用新的fetch api，它创建如下承诺：

var req1 = fetch(…);
var req2 = fetch(…);
Promise.all([req1, re2, …]).then(…);

promise resolve函数只接受一个输入参数，因此如果需要传入多个内容，则必须将它们包含在单个对象中。比如，如果你必须要做以下事情：

database.openCollection()
    .then(function(collection){
        var result = collection.query(something);
        var resultObject = { result: result, collection: collection };
    })
    .then(function(resultObject){
        doSomethingSyncronousWithResult(resultObject.result);
        resultObject.collection.close();
    });

你不能使用全部承诺如果你所有的东西都不是承诺解决的结果，你可能需要这样做

免责声明：代码示例非常糟糕，但它解释了这个概念。

promise resolve函数只接受一个输入参数，因此如果需要传入多个内容，则必须将它们包含在单个对象中。比如，如果你必须要做以下事情：

database.openCollection()
    .then(function(collection){
        var result = collection.query(something);
        var resultObject = { result: result, collection: collection };
    })
    .then(function(resultObject){
        doSomethingSyncronousWithResult(resultObject.result);
        resultObject.collection.close();
    });

你不能使用全部承诺如果你所有的东西都不是承诺解决的结果，你可能需要这样做

免责声明：代码示例非常糟糕，但它解释了这个概念。

我建议您了解承诺，尤其是蓝鸟。您可以推广传统的回调方法

我还将在不同的文件中创建模型级函数。这里有一个例子

parent.js

const db = require("./connections/database");  // connection to database

const getChildForParent = function (parentId, childId, callback) {
    db.find({parent: parentId, child_id: childId}, "childrenTable", function(err, result) {
        if (err) {
            return callback(err);
        }
        return callback(null, result);
    });
};

const db = require("./connections/database");  // connection to database

const getToysForChild = function (childId, callback) {
    db.find({toy_belongs_to: parentId}, "toysTable", function(err, result) {
        if (err) {
            return callback(err);
        }
        return callback(null, result);
    });
};

children.js

const db = require("./connections/database");  // connection to database

const getChildForParent = function (parentId, childId, callback) {
    db.find({parent: parentId, child_id: childId}, "childrenTable", function(err, result) {
        if (err) {
            return callback(err);
        }
        return callback(null, result);
    });
};

const db = require("./connections/database");  // connection to database

const getToysForChild = function (childId, callback) {
    db.find({toy_belongs_to: parentId}, "toysTable", function(err, result) {
        if (err) {
            return callback(err);
        }
        return callback(null, result);
    });
};

然后在控制器中，您可以执行以下操作：

const Bluebird = require("bluebird");
const Parent = require("./parent.js");
const Child = require("./child.js");

// Promisifying adds "Async" at the end of your methods' names (these are promisified)
Bluebird.promisifyAll(Parent); 
Bluebird.promisifyAll(Child);

// Just an example.
app.get("/parent/:parentId/children/:childId", function(req, res) {
    return Bluebird.try(function() {
         return User.getChildForParentAsync(req.params.parentId, req.params.childId);
    }).then(function(child) {
       return Child.getToysForChildAsync(child.child_id);
    }).then(function(toys) {
       // Do something with toys.
    });
});

当然，你可以用这个做更多的事情，这不是唯一的方法

您还可以使用

Promise.all（）

。当您希望等待多个承诺完成时，此方法非常有用

假设您有一个URL列表，希望在获取所有数据后获取并处理结果

var urls = [url1, url2, url3, url4, url5 .......... ];
var Bluebird = require("bluebird");
var request = require("request"); // callback version library

Bluebird.promisifyAll(request);

// create a list which will keep all the promises
var promises = [];

urls.forEach(function(url) {
    promises.push(request.getAsync(url1));
});

// promises array has all the promises
// Then define what you want to do on completion.

Bluebird.all(promises).then(function(results) {
    // results is an array with result a url in an index

    // process results.
});

我建议你学习承诺，尤其是蓝鸟。您可以推广传统的回调方法