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);