À l'aide Asynchrone en cascade dans node.js

D'abord et avant tout, assurez-vous que vous lire la documentation concernant async.cascade.

Maintenant, il ya quelques éléments clés à propos de la chute d'eau de contrôle de flux:

1. Le flux de contrôle est indiqué par un éventail de fonctions pour l'invocation comme premier argument, et "complet" de rappel lorsque le débit est fini comme deuxième argument.
2. L'éventail de fonctions sont appelées dans série (par opposition à l'parallèle).
3. Si un message d'erreur (généralement nommé err) est rencontré à toute opération dans le flux de tableau, il court-circuit et immédiatement appeler le "complète"/"terminer"/"fait" callback.
4. Des Arguments précédemment exécutée fonction sont appliquée à la fonction suivante dans le flux de contrôle, dans l'ordre, et un "intermédiaire" de rappel est fourni en tant que le dernier argument. Remarque: La fonction première n'a que ce "intermédiaire" de rappel, et la "complète" de rappel aura les arguments de la dernière fonction invoquée dans le flux de contrôle (en tenant compte de toutes les erreurs), mais avec un err argument ajouté à la place d'un "intermédiaire" callback qui est joint en annexe.
5. Les rappels pour chaque opération (j'appelle cela cbAsync dans mes exemples) doit être invoquée lorsque vous êtes prêt à passer: Le premier paramètre est une erreur, le cas échéant, et la deuxième (troisième, quatrième, etc...) paramètre sera toutes les données que vous souhaitez passer à l'opération suivante.

L'objectif premier est d'obtenir votre code de travail presque mot pour mot parallèlement à l'introduction de async.waterfall. J'ai décidé de supprimer tous vos console.log états et simplifiée de votre erreur de manipulation. Voici la première itération (code non testé):

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.');
        }
    });
}

La deuxième itération divise l'opération de débit un peu plus. Il le met dans de plus petits une seule opération tournée des morceaux de code. Je ne vais pas la commenter, il parle de lui-même (de nouveau, non testé):

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

La dernière itération de court-mains beaucoup de cela avec l'utilisation de certains bind astuces pour diminuer la pile d'appel et d'accroître la lisibilité (OMI), également non testé:

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