Korzystanie z asynchronicznego wodospadu w węźle.js

Przede wszystkim upewnij się, że przeczytałeś dokumentację dotyczącą async.waterfall.

Teraz jest kilka kluczowych części o przepływie kontroli wodospadu:

1. przepływ sterujący jest określony przez tablicę funkcji do wywołania jako pierwszy argument i wywołanie zwrotne "kompletne", gdy przepływ zostanie zakończony jako drugi argument.
2. tablica funkcji jest wywoływana w serii (W przeciwieństwie do parallel).
3. Jeśli błąd (Zwykle nazwany err) jest napotkany przy każdej operacji w tablicy przepływu, spowoduje zwarcie i natychmiast wywoła "complete"/"finish"/"done" callback.
4. argumenty z poprzednio wykonanej funkcji są stosowane do następnej funkcji w przepływie sterowania, w kolejności, a "pośredni" wywołanie zwrotne jest dostarczane jako ostatni argument. Uwaga: pierwsza funkcja ma tylko to "pośrednie" wywołanie zwrotne, a" kompletne " wywołanie zwrotne będzie miało argumenty ostatniej wywołanej funkcji w przepływ sterowania (z uwzględnieniem wszelkich błędów), ale z argumentem err poprzedzonym zamiast "pośredniego" wywołania zwrotnego, który jest dołączany.
5. wywołania zwrotne dla każdej pojedynczej operacji (wywołuję to cbAsync w moich przykładach) powinny być wywoływane, gdy jesteś gotowy do przejścia: pierwszy parametr będzie błędem, jeśli w ogóle, a drugi (trzeci, czwarty... itd.) parametrem będą wszelkie dane, które chcesz przekazać do następnej operacji.

Pierwszym celem jest zdobycie kodu praca niemal dosłowna wraz z wprowadzeniem async.waterfall. Postanowiłem usunąć wszystkie Twoje console.log wypowiedzi i uprościć obsługę błędów. Oto pierwsza iteracja (nieprzetestowany kod):

var fs = require('fs'),
    async = require('async');

function updateJson(ticker,value) {
    async.waterfall([ // the series operation list of `async.waterfall`
        // waterfall operation 1, invoke cbAsync when done
        function getTicker(cbAsync) {
            fs.readFile('stocktest.json',function(err,file) {
                if ( err ) {
                    // if there was an error, let async know and bail
                    cbAsync(err);
                    return; // bail
                }
                var stocksJson = JSON.parse(file);
                if ( stocksJson[ticker] === null ) {
                    // if we don't have the ticker, let "complete" know and bail
                    cbAsync(new Error('Missing ticker property in JSON.'));
                    return; // bail
                }
                stocksJson[ticker] = value;
                // err = null (no error), jsonString = JSON.stringify(...)
                cbAsync(null,JSON.stringify(stocksJson,null,4));    
            });
        },
        function writeTicker(jsonString,cbAsync) {
            fs.writeFile('stocktest.json',jsonString,function(err) {
                cbAsync(err); // err will be null if the operation was successful
            });
        }
    ],function asyncComplete(err) { // the "complete" callback of `async.waterfall`
        if ( err ) { // there was an error with either `getTicker` or `writeTicker`
            console.warn('Error updating stock ticker JSON.',err);
        } else {
            console.info('Successfully completed operation.');
        }
    });
}

Druga iteracja nieco bardziej dzieli przebieg operacji. Umieszcza go w mniejszych, zorientowanych na jedną operację kawałkach kodu. Nie będę tego komentował, to mówi samo za siebie (ponownie, nieprzetestowane):

var fs = require('fs'),
    async = require('async');

function updateJson(ticker,value,callback) { // introduced a main callback
    var stockTestFile = 'stocktest.json';
    async.waterfall([
        function getTicker(cbAsync) {
            fs.readFile(stockTestFile,function(err,file) {
                cbAsync(err,file);
            });
        },
        function parseAndPrepareStockTicker(file,cbAsync) {
            var stocksJson = JSON.parse(file);
            if ( stocksJson[ticker] === null ) {
                cbAsync(new Error('Missing ticker property in JSON.'));
                return;
            }
            stocksJson[ticker] = value;
            cbAsync(null,JSON.stringify(stocksJson,null,4));
        },
        function writeTicker(jsonString,cbAsync) {
            fs.writeFile('stocktest.json',jsonString,,function(err) {
                cbAsync(err);
            });
        }
    ],function asyncComplete(err) {
        if ( err ) {
            console.warn('Error updating stock ticker JSON.',err);
        }
        callback(err);
    });
}

Ostatnia iteracja krótka-ręce dużo tego z wykorzystaniem niektórych bind niektóre z nich nie są już dostępne, a niektóre z nich nie są dostępne.]}

var fs = require('fs'),
    async = require('async');

function updateJson(ticker,value,callback) {
    var stockTestFile = 'stocktest.json';
    async.waterfall([
        fs.readFile.bind(fs,stockTestFile),
        function parseStockTicker(file,cbAsync) {
            var stocksJson = JSON.parse(file);
            if ( stocksJson[ticker] === null ) {
                cbAsync(new Error('Missing ticker property in JSON.'));
                return;
            }
            cbAsync(null,stocksJson);
        },
        function prepareStockTicker(stocksJson,cbAsync) {
            stocksJson[ticker] = value;
            cbAsync(null,JSON.stringify(stocksJson,null,4));
        },
        fs.writeFile.bind(fs,stockTestFile)
    ],function asyncComplete(err) {
        if ( err ) {
            console.warn('Error updating stock ticker JSON.',err);
        }
        callback(err);
    });
}

Zasadniczo funkcje nodejs (i bardziej ogólnie javascript), które wymagają trochę czasu do wykonania (czy to dla I/O lub przetwarzania cpu) są zazwyczaj asynchroniczne, więc pętla zdarzeń (aby uprościć to jest pętla, która stale sprawdza zadania do wykonania) może wywołać funkcję tuż pod pierwszą, bez blokowania odpowiedzi. Jeśli znasz inne języki, takie jak C lub Java, możesz uznać funkcję asynchroniczną za funkcję, która działa w innym wątku (nie jest w javascript jest to koniecznie prawda, ale programista nie powinien się tym przejmować) i po zakończeniu wykonania wątek ten powiadamia głównego (pętlę eventową), że zadanie zostało wykonane i ma wyniki.

Jak wspomniano, gdy pierwsza funkcja zakończyła swoje zadanie, musi być w stanie powiadomić, że jej zadanie jest zakończone i robi to wywołując funkcję zwrotną, którą mu przekazujesz. aby zrobić przykład:

var callback = function(data,err)
{
   if(!err)
   {
     do something with the received data
   }
   else
     something went wrong
}


asyncFunction1(someparams, callback);

asyncFunction2(someotherparams);

Przepływ wykonania wywoła: asyncFunction1, asyncFunction2 i każdy funkcja poniżej do momentu zakończenia asyncFunction1, wtedy funkcja callback, która jest przekazywana jako ostatni parametr do asyncFunction1 jest wywoływana, aby zrobić coś z danymi, jeśli nie wystąpiły błędy.

Tak więc, aby 2 lub więcej funkcji asynchronicznych wykonywało się jedna po drugiej tylko wtedy, gdy się skończyły, musisz wywołać je wewnątrz ich funkcji zwrotnych:

function asyncTask1(data, function(result1, err)
{
   if(!err)
     asyncTask2(data, function(result2, err2)
     {
           if(!err2)
        //call maybe a third async function
           else
             console.log(err2);
     });
    else
     console.log(err);
});

Result1 jest wartością zwracaną z asyncTask1, a result2 jest wartością zwracaną dla asyncTask2. Możesz w ten sposób zagnieżdżać ile asynchronicznych funkcje, które chcesz.

W Twoim przypadku jeśli chcesz wywołać inną funkcję po updatejson () musisz wywołać ją po tej linii:

console.log("File successfully written");