Question

目前正在尝试学习Node JS并了解Async / Sync工作流程。

尝试以下方法：

第1步： - 使用功能1获取数据1 - 使用功能2获取数据2 - 使用功能3获取数据3

步骤2： - 使用数据1,2,3

计算出逻辑

第3步 - 做最后的决定

我一直在关注Q和Async软件包，但仍然没有真正找到一个例子。

有人可以告诉我他们将如何在Node JS中解决这个问题吗？

由于

Answer 1

您的实施并不完全清楚，但根据您的订购需求的具体情况，您可以尝试以下方式：

var data1 = null;
var data2 = null;
var data3 = null;

async.series([
    function(httpDoneCallback){
        async.parallel([
            function(data1Callback){
                $http(...).then(function(response){
                    // some logic here
                    data1 = response;
                    data1Callback();
                })
            },
            function(data2Callback){
                $http(...).then(function(response){
                    // some logic here
                    data2 = response;
                    data2Callback();
                })
            },
            function(data3Callback){
                $http(...).then(function(response){
                    // some logic here
                    data3 = response;
                    data3Callback();
                })
            }
        ], function(){
            //all requests dome, move onto logic
            httpDoneCallback();
        })
    },
    function(logicDoneCallback){
        // do some logic, maybe more asynchronous calls with the newly acquired data
        logicDoneCallback();
    }
], function(){
    console.log('all done');
})

Answer 2

您是否希望同时触发功能1,2和3？如果是这样，那么这应该有所帮助：

var async = require('async');
async.parallel([
    function(cb1) {
        cb1(null, "one")
    },
    function(cb2){
        cb2(null, "two")
    },
    function(cb3){
        cb3(null, "three")
    }
], function(err, results) {
    console.log(results); // Logs ["one", "two", "three"]
    finalCall();
});

为了解释，作为并行方法的第一个参数提交的数组中的每个函数也将接收回调函数。激活回调函数表示您已完成获取数据或在所述函数中执行您需要执行的任何操作。所有三个函数将同时触发，一旦调用所有三个回调，就会调用最终函数。回调接受两个参数：＆＃34;错误＆＃34;和＆＃34;结果。＆＃34;如果一切顺利，通过＆＃34; null＆＃34;作为错误参数。结果将作为包含各个函数的每个结果的数组提供给最终函数。

Answer 3

您可以设置Promises链来按顺序执行操作：

var funcA = () => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('some data from A')
        }, 1000)
    });
}

var funcB = (dataFromA) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(dataFromA + ' data from B')
        }, 2000)
    })
}

var funcC = (dataFromB) => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(dataFromB + ' data from C')
        }, 500)
    })
}

// Doing the functions on after another
funcA().then(funcB).then(funcC).then((data) => {
    console.log(data);
})

或者如果您想同时使用Promise.all()：

var promises = [];

promises.push(new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve('some data from A')
    }, 1000)
}));

promises.push(new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve('some data from B')
    }, 1000)
}));

promises.push(new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve('some data from C')
    }, 1000)
}));

// Execute the array of promises at the same time, and wait for them all to complete
Promise.all(promises).then((data) => {
    console.log(data);
})

Answer 4

可能最好的办法是使用像@Tyler这样的Promise。但是，对于概念性理解，最好先了解节点回调模式。

因为某些任务需要时间，所以我们为任务提供一个函数并说“完成后，将检索到的数据放入此函数中”。我们为其他函数提供的这些函数称为回调函数。它们必须构造为接受数据，并且在获取数据时出现问题时也会出错。在Node中，错误是第一个回调参数，数据是第二个。

fs.readFile('/file/to/read.txt', function callback(error, data) {        
  if (error) console.log(error);  
  else console.log(data);
});

在此示例中，一旦节点读取文件，它就会将该数据提供给回调函数。在回调中，我们必须考虑到存在问题并处理错误的情况。

在您的问题中，您希望执行多个异步任务并使用其结果。因此，您必须采用此模式并嵌套其中的几个。因此，继续此示例，如果没有错误，您将开始另一个异步任务。

fs.readFile('/file/to/read.txt', function callback(error, data) {        
  if (error) console.log(error);  
  else {
    someOtherAsyncThing(function callback(error, data2) {
      if (error) console.log(error);
      else {
        console.log(data + data2)
      }
    });
  }
});

节点JS同步工作流与异步请求

4 个答案: