Question

我无法理解为执行此代码而打印的输出：

1 2 未处理的拒绝错误：已经调用了回调。

当查询成功时，似乎会执行then和catch。

有什么想法吗？

干杯

    async.series([
            function(callback) {
                db.none(query)
                    .then(function () {
                        return callback(null, true);
                    })
                    .catch(function (err) {
                        return callback(err, null);
                    });
            },
            function(callback) {
                db.any(query)
                    .then(function (data) {
                        console.log('1')
                        return callback(null, data);
                    })
                    .catch(function (err) {
                        console.log('2')
                        console.log(err);
                        return callback(err, null);
                    });
            }
        ],
        function(err, results) {
           if (results && !results[1].isEmpty()) {
              // do something
           }
        });

编辑：

TypeError: results[1].isEmpty is not a function

似乎问题来自其余的代码，只是一个简单的未定义函数错误，谢谢。

但我仍然不明白：为什么这个错误会在第二个查询中被捕获而不是在异步查询之外？

Answer 1

我是pg-promise的作者。

您永远不应该将async库与pg-promise一起使用，这违背了共享/可重用连接的概念。

通过任务正确使用相同的连接实现：

db.task(t => {
    return t.batch([
        t.none(query1),
        t.any(query2)
    ]);
})
    .then(data => {
        // data[0] = null - result of the first query
        // data[1] = [rows...] - result of the second query

        callback(null, data); // this will work, but ill-advised
    })
    .catch(error => {
        callback(error, null); // this will work, but ill-advised
    });

另请参阅：Chaining Queries。

但是，在您的情况下，当您调用成功的callback(null, data)时，它会抛出一个错误，从而导致它被捕获到以下.catch部分。要对此进行测试，您可以像这样更改承诺处理程序：

    .then(data => {
        callback(null, data);
    }, error => {
        callback(error, null);
    });

通常应该抛出一个关于Promise丢失.catch的错误，因为您在.then时发生了错误，并且下面没有相应的.catch链接，您也可以通过此代码检查：

    .then(data => {
        callback(null, data);
    }, error => {
        callback(error, null);
    })
    .catch(error => {
        // if we are here, it means our callback(null, data) threw an error
    });

P.S。你真的应该学会正确使用promises，并完全避免任何回调。我只提供了一个与你自己一致的例子，但一般来说，将promises转换为回调是一种非常糟糕的编码技术。

Answer 2

这就是：

callback(null, data)在.then();
async注意到这是该系列的最后一项，因此它调用最终处理程序（仍然在.then()的上下文中）;
最终处理程序抛出错误;
因为代码在.then()的上下文中运行，所以promise实现会捕获错误并调用.catch();
这会再次调用;

;

的PoC：

const async = require('async'); async.series([ callback => { Promise.resolve().then(() => { callback(null); }).catch(e => { callback(e); }); } ], err => { throw Error(); })

Answer 3

您是否尝试在外部定义您的功能：

function onYourFunction() {
   console.log('Hi function');
}

而不是：

.then(onYourFunction)    //-->(onYourFunction without parentheses )

不幸的是我没有使用pg-promise，但我可以建议promise

此时我创造了所有必要的承诺：

function createPromise(currObj) {
return new Promise(function (resolve, reject) {
    currObj.save(function (errSaving, savedObj) {
        if(errSaving){
            console.log("reject!");
            return reject(errSaving, response);
        }

        console.log('currObj:' + currObj);
        return resolve(savedObj);
    });
});

}

然后是级联：

var allPromiseOs = Promise.all(promise1, promise2, promise3);

错误：在使用异步系列

3 个答案: