Question

我想在顺序总线中运行循环功能，该功能总是异步的有什么方法可以使其同步而无需使用回调或任何外部库

文件1

var db = require('./promiseUnderStanding');

var fun = function () {
    for (var i = 0; i < 10; i++) {
        db.getFromDb(i, 0);
    }
}
fun();

file2

var mysql = require("mysql");
module.exports = {
 getFromDb : function (num1,num2) {
    var mysql = require('mysql');
    var connection = mysql.createConnection({
        host: 'localhost',
        user: 'root',
        password: 'root',
        database: 'demo'
    });
    connection.connect();
    connection.query('SELECT '+num1+' + '+num2 +' AS solution', function (error, results, fields) {
        if (error) {
            console.log(err)
        }
        else {
            console.log('The solution is: ', results[0].solution);
        }
    })
    connection.end();
}

}

Answer 1

如果函数异步，则意味着它返回一个Promise。

const myFunc = function(){
    return new Promise(function(resolve, reject){
        if(failed){
            reject(dataSendToCatch);
        }if(!failed){
            resolve(dataSendToThen);
        }
    })
};

这几乎与以下内容相同：

const myFunc = async function(){
    if(failed) throw new Error();
        return dataSendToThen;
};

运行函数后，您可以链接异步甚至同步函数：

myFunc()
.then(function(dataFromResolve){return otherFunc()})
.then(function(dataFromOtherFunc){/*...*/});

对于连续处理，过滤，映射来自异步函数的接收数据，这是一个很好的rxjs库。

Answer 2

无法同步运行异步诺言。

不过，您要寻找的是Promise.all()。另外connection.open也是异步的，快速打开和关闭与mysql的连接效率不高。您应该在循环之前打开连接，执行查询然后关闭它（在我的示例中未显示）。

示例

文件1：

var db = require('./promiseUnderStanding');

var fun = function () {
    var promises = [];
    for (var i = 0; i < 10; i++) {
        promises.push[db.getFromDb(i, 0)];
    }
    Promise.all(promises).then(function(values){
        console.log(values):
    })
}
fun();

文件2：

var mysql = require("mysql");
module.exports = {
    getFromDb : function (num1,num2) {
    var mysql = require('mysql');
    var connection = mysql.createConnection({
        host: 'localhost',
        user: 'root',
        password: 'root',
        database: 'demo'
    });
    var queryPromise = new Promise(function(resolve, reject) {
        connection.connect(function(err){
            connection.query('SELECT '+num1+' + '+num2 +' AS solution', function (error, results, fields) {
                if (error) {
                    reject(error)
                }
                else {
                    resolve(results)
            }
        });
    })})
    connection.end();
    return queryPromise;
    }
}

Answer 3

您的问题似乎与异步函数有关，所以我认为数据库逻辑超出范围。

使用async-await：

文件1：

const fun = async function () {
    for (var i = 0; i < 10; i++) {
        await db.getFromDb(i, 0);
    }
}
fun().then(onFinish).catch(onError);

文件2：

module.exports.getFromDb = function() {
    return new Promise((resolve, reject) => {
        // If success
        resolve(result);
        // If fail
        reject(error);
    });
}

返回 Promise 的函数是异步的。
承诺必须解决或拒绝。
在调用异步函数 B 来等待 B 承诺解决或拒绝

A

如果使用 async 关键字定义函数，则其返回值将包装在隐式Promise中。

使用then（）使函数在节点中顺序运行

3 个答案: