node.js - node - Asyncjs: omite una función en una cadena de cascada

node js example

Question

Quiero saltar una función de una cadena de funciones de cascada con asyncjs en nodejs .

Mi código se ve así:

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){
    }
]);

¿Conoces una forma adecuada de hacer esto sin ponerlo?

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

En la función que quiero omitir.

Gracias !

Answer 1

Una alternativa podría ser:

var tasks = [f1];

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

tasks.push(f3);

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

donde f1 , f2 y f3 son sus funciones.

aparte de eso, es mejor que lo hagas de forma explícita, evitando que el código sea demasiado complicado, más simple, por lo general, mejor

actualizar:

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 2

Creo que esto debería funcionar:

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
)

el creador de async recomienda esto en el repositorio github ( https://github.com/caolan/async/pull/85 )

Answer 3

Al usar el módulo if-async , su código se verá así:

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

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

para ver un ejemplo completo, mira aquí: https://github.com/kessler/if-async#example-2-using-with-asyncjs-waterfall

Answer 4

Recomendaría usar clojurescript, que tiene una asombrosa biblioteca core-async que hace la vida muy fácil cuando se trata de llamadas asíncronas.

En tu caso, escribirías algo como esto:

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

Tenga en cuenta la macro go que hará que el cuerpo se ejecute de forma asíncrona, y el <! función que bloqueará hasta que vuelvan las funciones asíncronas.

El código primero se bloqueará en la primera función asíncrona. Luego, si el resultado es cierto, también ejecutará la segunda función asíncrona en el bloque. Por último, ejecutará la tercera función asíncrona y bloqueará eso.

Answer 5

Llego tarde para responder, pero async-if-else podría ayudarte.

Código de muestra

 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: ''[email protected]'', dogs: 2, money: 0, fun: 100 }),
    async.if(emailExists, updateAccount).else(importFromLegacyByEmail),
    sendEmail
  ], handler);