Question

我正在使用node / epxress，mysql和bluebird。

我正在客户端请求后执行异步数据库操作。在第一个数据库操作的回调中，我必须首先执行一些计算，然后再执行两次数据库查询，这些查询是为客户端提供正确结果所必需的。

我的代码被分成一个Controller类，它处理get / post请求。中间是业务逻辑的服务类，它与在数据库中查询的数据库类进行通信。

我当前能够执行第一个和第二个数据库请求。

getVacation(departmentID) {

        return departmentDatabase.getVacation(departmentID)
            .then(result => [ result, result.map(entry => this.getDateRange(new Date(entry.dateFrom), new Date(entry.dateTo))) ])
            .spread(function(result, dateRange){
                var mergedDateRange = [].concat.apply([], dateRange);
                var counts = {};
                mergedDateRange.forEach(function(x) { counts[x] = (counts[x] || 0)+1; });

                return [{"vacationRequest": result, "dateRange": dateRange, "countedDateRange": counts}];
            })
             .then( result => [result, departmentDatabase.countUser(departmentID)])
             .spread(function (result, userOfDepartmentCount){
                console.log(userOfDepartmentCount);
                console.log(result);
                //console.log(blocked);

                return departmentID; //return just for not running into timeout
            })
            .catch(err => {
                // ...do something with it...
                // If you want to propagate it:
                return Promise.reject(err);
                // Or you can do:
                // throw err;
            });
    }

但是当试图执行第三次我遇到麻烦时。为了解决这个问题，我阅读了Bluebird Docs，它指向.all()或（甚至更好）.join()。但试图使用其中任何一个都不适合我。

如果我使用.join()进行尝试，则始终会生成join is not a function，我觉得这很困惑，因为我可以使用所有其他功能。我也试过要求

var Promise = require("bluebird");
var join = Promise.join;

但即使这样做也没有帮助。

目前我只需要在我的数据库类中使用Bluebird作为Promise。

所以现在我的整个服务类。

'use strict';

var departmentDatabase = require('../database/department');
var moment = require('moment');

class DepartmentService {
    constructor() {
    }

    getVacation(departmentID) {

        return departmentDatabase.getVacation(departmentID)
            .then(result => [ result, result.map(entry => this.getDateRange(new Date(entry.dateFrom), new Date(entry.dateTo))) ])
            .spread(function(result, dateRange){
                var mergedDateRange = [].concat.apply([], dateRange);
                var counts = {};
                mergedDateRange.forEach(function(x) { counts[x] = (counts[x] || 0)+1; });

                return [{"vacationRequest": result, "dateRange": dateRange, "countedDateRange": counts}];
            })
            //THIS DOES NOT WORK
            .join(result => [result, departmentDatabase.countUser(departmentID), departmentDatabase.blockedDaysOfResponsible(departmentID)])
            .spread(function (result, userOfDepartmentCount, blocked){
                console.log(userOfDepartmentCount);
                console.log(result);
                console.log(blocked);

                return departmentID;
            })
            .catch(err => {
                // ...do something with it...
                // If you want to propagate it:
                return Promise.reject(err);
                // Or you can do:
                // throw err;
            });
    }

    getDateRange(startDate, stopDate) {
        var dateArray = [];
        var currentDate = moment(startDate);
        while (currentDate <= stopDate) {
            dateArray.push(moment(currentDate).format('YYYY-MM-DD'))
            currentDate = moment(currentDate).add(1, 'days');
        }

        return dateArray;
    }
}

module.exports = new DepartmentService();

是否有人能够举例说明如何正确行事？

编辑：

这里是我在databaseCall中使用的示例代码，用于返回db结果和promise

return Promise.using(dbConnection.getConnection(), function (conn) {
            return conn.queryAsync(sql, [departmentID])
                .then(function (result) {
                    return result;
                })
                .catch(function (err) {
                    return err;
                });
        });

Answer 1

Promise.join很不错，但它可能不适合你的情况。 Promise.all会将您所拥有的几项承诺合并为一个解决方案：

.then(result => Promise.all([result, departmentDatabase.countUser(departmentID), departmentDatabase.blockedDaysOfResponsible(departmentID)])]‌))

然后你可以将结果（数组）传播到函数调用中：

.spread(function(a, b, c) {
    console.log("Results", a, b, c);
});

Promise.all接受一个Promises数组，等待所有它们解析（或拒绝），然后继续将有序数组中的结果存入随后的.then（或其他promise）子句

Answer 2

如果你正在寻找一个能让控制更容易控制的模块，那么你可能会想relign。 Promise.all可以在这里解决问题，但如果您需要已解决的结果，那么relign.parallel或relign.series可能会更适合您。

使用.join（）在async promise中调用async promise

2 个答案: