node.js - Asyncjs：绕过瀑布链中的函数

Question

我想从 in 的瀑布函数链中跳转一个asyncjs函数nodejs。

我的代码如下所示：

async.waterfall([
    function(next){
        if(myBool){
            next(null);
        }else{
            // Bypass the 2nd function
        }
    },

    // I want to bypass this method if myBool is false in the 1st function
    function(next){
    },

    // Always called
    function(next){
    }
]);

您是否知道不使用 put 的正确方法：

if(!myBool){
    return next();
}

在我想绕过的功能中。

谢谢 ！

Answer 1

我认为这应该有效：

var finalCallback = function(err, result){
  if(err)
     // handle error..
  else
     console.log('end! :D');
}

async.waterfall(
  [
    function step1(callback){
       // stuff
       callback(null, someData);
    },
    function step2(someData, callback){
       if(skip_step_3)
          finalCallback(null, someData);
       else
          callback(null, someData);
    },
    function step3(moreData, callback){
       // more stuff
       callback(null, moreData);
    }
  ],
  finalCallback
)

async 的创建者在 github repo ( https://github.com/caolan/async/pull/85 )中推荐这个

Answer 2

另一种选择可能是：

var tasks = [f1];

if(myBool){
    tasks.push(f2);
}

tasks.push(f3);

async.waterfall(tasks, function(err, result){
});

其中f1,f2和f3是您的函数。

除此之外，你最好明确地这样做，避免让你的代码过于复杂，简单通常更好

更新：

function f1(done){
    if(myBool){
        f2(done);
    }else{
        done();
    }
}

function f2(done){
    async.nextTick(function(){
        // stuff
        done();
    });
}

async.waterfall([f1,f3],function(err,result){
    // foo
});

Answer 3

使用if-async模块，您的代码将如下所示：

var async = require('async')
var ifAsync = require('if-async')

async.waterfall([
    foo,
    ifAsync(p1).then(c1).else(c2),
    bar
], function(err) {})

完整示例请看这里：https ://github.com/kessler/if-async#example-2-using-with-asyncjs-waterfall

Answer 4

我迟到了，但async-if-else可能会对你有所帮助。

示例代码

 var async = require('async-if-else')(require('async'));

  function emailExists(user, callback) {
    user.find(user.email, function(err, dbUser){
      if (err)
        return callback(error);

      if(!dbUser)
     return callback(null, false); // does not exist, predicate will be false 

   callback(null, true);  
  });
  }

  function updateAccount(user, callback) { 
    user.update( ..., callback);
  }

  function importFromLegacyByEmail(user, callback) { 
    remoteClient.get(user, callback);
  }

  async.waterfall([
    async.constant({email: 'thiago@email.com', dogs: 2, money: 0, fun: 100 }),
    async.if(emailExists, updateAccount).else(importFromLegacyByEmail),
    sendEmail
  ], handler);

Answer 5

我会推荐使用clojurescript，它有一个很棒的核心异步库，它在处理异步调用时让生活变得超级简单。

在你的情况下，你会写这样的东西：

(go
  (when-let [res1 (<! (asyncFunc1))]
    (<! (asyncFunc2 res1)))
  (<! (asyncFunc3)))

请注意go将导致主体异步运行的宏，以及<!将阻塞直到异步函数返回的函数。

代码将首先阻塞第一个异步函数。然后，如果结果为真，它也会在该块上运行第二个异步函数。最后，它将运行第三个异步函数并阻止它。