用async 解放你的大脑

在js中，代码嵌套和代码回调非常常见，不仅编写麻烦而且异常反人类。让我等码农很是头痛

function () {
    function () {
        function () {
            function () {
                //pass
            }
        }
    }
}

 这是一个常规的嵌套，如果每个function 的逻辑处理都比较多的话，会导致整个代码非常长，不仅编码困难，而且阅读起来也是很是蛋疼， 这种情况在js 中还是比较好的情况 ，还有非常恶劣的情况 ，考虑下在 异步嵌套的情况

var path = './async.txt';
// check if async.txt exists
fs.stat(path, function (err, stats) {
    if (err)
        return err
    if (stats == undefined) {
        fs.readFile(__filename, function (err, content) {
            if (err)
                return err
            var code = content.toString();
            fs.writeFile(path, code, function (err) {
                if (err)
                    return err
                console.log('async.txt created!');
            });
        });
    }
});

 

 这是一个异步嵌套代码，先检查文件是否存在，不存在则把某个文件的内容提取出来然后在写入另外一个文件，看起来还算好，但是遗憾的是这样的编写无法把错误 return 到顶层例如 fs.writeFile return 的err 无法 在fs.stat 中接受到。如果想在外层接受到内部抛出的错误你会见到非常反人类的代码，如下

function start (path,filePath){
    stats(path,function(err,stat){
        if (err)                       
            return err;        
        else if(stat == undefined){
            reads(filePath,function(err,data){
                if (err)
                    return err;
                var code = data.toString();
                writes(code,function(err,result){
                    if (err)
                        return err
                    console.log('async.txt created!');
                })                
            })
        }
    })
}


function stats (path, fn) {
    fs.stat(path, function (err, stats) {
        if (err)
            fn(err, null);
        fn(null, stats);
    });
}

function reads (filePath,fn){
    fs.readFile(filePath,function(err,content){
        if (err)
            fn(err, null);
        fn(null, content);
    });
}


function writes(data,fn){
    fs.writeFile(filePath,data,function(err,content){
        if (err)
            fn(err, null);
        fn(null, content);
    });
}

 

wtf ，这样恶心的代码 实在无法让人喜欢，但是不得已为之，如果想在外层接受错误信息在没有async 之前 常规的写法就是上面那样 把异步代码包括回调抽出来成为一个单一的方法 然后调用，这样会导致代码的结构更加臃肿 更加反人类，看了一眼就不想看第二眼的！ 不仅编写的痛苦，维护的更痛苦

但是有了async 一切就不同了

 

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

var path = './async.txt';
async.waterfall([
    // check if async.txt exists
    function(cb) {
        fs.stat(path, function(err, stats) {
            if (stats == undefined) cb(null);
            else console.log('async.txt exists');
        });
    },
    // read the contents of this file
    function(cb) {
        fs.readFile(__filename, function(err, content) {
            var code = content.toString();
            cb(null, code);
        });
    },
    // write the content to async.txt
    function(code, cb) {
        fs.writeFile(path, code, function(err) {
            if (err) throw err;
            console.log('async.txt created!');
        });
    }
]);

改变之后的结构就像同步那样编写异步回调代码，不仅结构清晰而且代码编写非常简单，写完之后顿时 头不痛了，腿不酸了，感觉时间如此美好了 ！这等利器真是解放我等码农的大杀器啊！ 当然还有老赵的 wind.js 更符合。net 4.5 中async 和await 的写法 ，很是犀利

async 传送门 https://github.com/caolan/async#waterfall
wind.js 传送门 http://windjs.org/cn/

当然在nodejs 鼎鼎大名的 async 不会只有这点功能，奈何小弟才疏学浅，疏于皮毛，仅会于此，如有任何错误，欢迎拍砖
enjoy ！