使用then（）使函數在節點中按順序運行

Question

我想在序列總線中運行循環函數，函數總是得到異步有沒有任何方法使它同步而不使用回調或任何外部庫

檔案1

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

var fun = function () {
    for (var i = 0; i < 10; i++) {
        db.getFromDb(i, 0);
    }
}
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'
    });
    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){/*...*/});

對於連續處理，過濾， maping從異步函數接收數據是很好的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的承諾解析或拒絕時，在async函數A中使用await
• 如果使用async關鍵字來定義函數，則其返回值將包含在隱式Promise中。