Limpe aquela hierarquia de callback feia de node.js com async.waterfall

O Node.js é incrível, mas todos os retornos de chamada aninhados assíncronos certamente tornam o código difícil de ler – por exemplo, o caso abaixo, onde foo (), bar () e baz () são chamados em sucessão:

foo(function(err, ret) {
    // ...
    if(err) return handleError(err);
    else bar(function(err, ret) {
        // ...
        if(err) return handleError(err);
        else baz(function(err, ret) {
            // ...
            if(err) return handleError(err);
            else console.log('we are done');
        }
    }
}

O código acima machuca meus olhos e deve machucar os seus também, porque ambos sabemos que o exemplo acima é inofensivo em comparação com o mundo real e que os manipuladores de retorno de chamada aninhados se tornam ilegíveis após apenas alguns recuos. Isso é difícil de ler e de depurar.

Felizmente, existem alternativas para essa bagunça. Um dos meus favoritos é async.waterfall ():

async.waterfall([
    function(next) {
        foo(next);
    },
    function(data, next) {
         bar(next);
    },
    function(data, next) {
        baz(next);
    }
],
function(){
    if(err) return handleError(err);
    else console.log('we are done');
}); 

Ou se você não tem outro código para chamar, mas as três funções (e todas elas seguem a convenção de retorno de chamada node.js padrão):

async.waterfall([
    foo, 
    bar, 
    baz],
    function(err, out) {
            if(err) return handleError(err);
            else console.log('we are done');
    });

o async é incrível porque o controle de fluxo inteligente é incrível e necessário e mantém você são. Obrigado, assíncrono.