node js 异步学习记录

假设一个场景，需要读取两个文件，然后把两个文件的内容倒序合并后输出，而且不能阻塞进程。

直接用回调来实现

var fs = require('fs');

var path1 = __dirname + '/package.json';
var path2 = __dirname + '/app.js';

console.log('start');

fs.readFile(path1, 'utf8', (err, content1) => {
    if (err) throw err;
    fs.readFile(path2, 'utf8', (err, content2) => {
        if (err) throw err;
        console.log(path2 + '\
' + content2 + '\
' + path1 + '\
' + content1);
    });
});

console.log('end');

如果有 n 个文件要读取，那就是回调地狱（Callback Hell）。

Callback Hell

使用 Promise 实现

直接使用原生 Promise

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

var path1 = __dirname + '/package.json';
var path2 = __dirname + '/app.js';


console.log('start');

var readFilePromise = (path) => {
    return new Promise((resolve, reject) => {
        fs.readFile(path, 'utf8', (err, content) => {
            if (err) reject(err);
            resolve(content);
        });
    });
};

Promise.resolve().then(() => {
    return readFilePromise(path1).then((content1) => {
        return content1;
    });
}).then((result)=>{
    return readFilePromise(path2).then((content2)=>{
        return path2 + '\
' + content2 + '\
' + path1 + '\
' + result;
    });
}).then((result)=>{
    console.log(result);
});
console.log('end');

readFilePromise 把 readfile 的 callback 转换为Promise，下面就可以直接用 then 方法了。

这里直接用 bluebird

var fs = require('fs');
var Promise = require('bluebird');

var path1 = __dirname + '/package.json';
var path2 = __dirname + '/app.js';

console.log('start');

Promise.promisifyAll(fs);

Promise.resolve().then(() => {
    return fs.readFileAsync(path1, 'utf8').then((content) => {
        return content;
    });
}).then((result) => {
    return fs.readFileAsync(path2, 'utf8').then((content) => {
        return path2 + '\
' + content + '\
' + path1 + '\
' + result;
    });
}).then((result) => {
    console.log(result);
});

console.log('end');

这里的 fs.readFileAsync 方法已经通过 bluebrid 转换成了 Promise。

如果有 n 个文件需要，那就需要加 n 个 then 方法。

改进的 Promise 实现方式

使用 Promise.all 方法

原生 Promise

var fs = require('fs');

var path1 = __dirname + '/package.json';
var path2 = __dirname + '/app.js';

console.log('start');

var readFilePromise = (path) => {
    return new Promise((resolve, reject) => {
        fs.readFile(path, 'utf8', (err, content) => {
            if (err) reject(err);
            resolve(content);
        });
    });
};

var files = [path1, path2];
var promises = [];
files.forEach((filePath) => {
    promises.push(readFilePromise(filePath));
});
Promise.all(promises).then((result) => {
    var contents = result.reverse();
    var out=[];
    files.reverse().forEach((filePath,index)=>{
        out.push(filePath);
        out.push(contents[index]);
    });
    console.log(out.join('\
'));
});
console.log('end');

bluebird 方式

var fs = require('fs');
var Promise = require('bluebird');

var path1 = __dirname + '/package.json';
var path2 = __dirname + '/app.js';

console.log('start');

Promise.promisifyAll(fs);

var files = [path1, path2];
var fileReadPromise = [];
files.forEach((filePath) => {
    fileReadPromise.push(fs.readFileAsync(filePath, 'utf8'));
});
Promise.all(fileReadPromise).then((result) => {
    var contents = result.reverse();
    var out=[];
    files.reverse().forEach((filePath,index)=>{
        out.push(filePath);
        out.push(contents[index]);
    });
    console.log(out.join('\
'));
});

console.log('end');

这样的话，不管有多少文件，只要放入 files 数组即可。

两种 Promise 实现是有区别的，第一种方式是顺序读取文件，读完一个再读另外一个，第二种方式是同时开始读取，全部完成后返回。

使用Generator实现

Generator 概念

var fs = require('fs');

var path1 = __dirname + '/package.json';
var path2 = __dirname + '/app.js';

console.log('start');

var thunkReadFile = function (path) {
    return function (cb) {
        fs.readFile(path, 'utf8', (err, content) => {
            cb(err, content);
        });
    };
};

function* readAllFile() {
    var content1 = yield thunkReadFile(path1);
    var content2 = yield thunkReadFile(path2);
    console.log(path2 + '\
' + content2 + '\
' + path1 + '\
' + content1);
}


var rf = readAllFile();
var fn1 = rf.next().value;
fn1(function (err, con1) {
    if (err) rf.throw(err);
    var fn2 = rf.next(con1).value;
    fn2(function (err, con2) {
        if (err) rf.throw(err);
        rf.next(con2);
    });
});
console.log('end');

这样写不就还是 Callback Hell, 这是为了了解Generator.

function* 定义了一个 Generator function, 那么 rf 就是 Generator，它会有 next 方法，返回一个{value : (object),done: (boolean)}的对象，其中的 value 就是 yield 后面返回的值。每次调用 next 就会向下执行一个 yield，直到没有 yield 后返回的对象里 done就为true，而每次调用 next 的参数会作为 yield 的返回值。

以上面的代码来说，

var fn = rf.next().value;

这里执行后就到了第一个 yield 停住

var content1 = yield thunkReadFile(path1);

那么 next 返回的对象中的 value 就是 thunkReadFile(path1)，这里已经赋值给了 fn1。这里要注意 yield 还没有返回，content1还没有值。

第二次执行 next 的时候

var fn2 = rf.next(con1).value;

得到了 thunkReadFile(path2)，同时将第一个 yield 的值通过 next 的参数返回,content1现在是第一个文件的内容.

第三次执行 next 的时候

rf.next(con2);

将第二个 yield 的值返回给 content2，同时整个 Generator function 执行完毕，输出结果。

当然也可以用 Promise 来实现这个过程。但是有更简单的方法，那就是 CO 库。

CO 实现

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

var path1 = __dirname + '/package.json';
var path2 = __dirname + '/app.js';

console.log('start');

var trunkReadFile = function (path) {
    return function (cb) {
        fs.readFile(path, 'utf8', (err, content) => {
            cb(err, content);
        });
    };
};

co(function* readAllFile() {
    var content1 = yield trunkReadFile(path1);
    var content2 = yield trunkReadFile(path2);
    console.log(path2 + '\
' + content2 + '\
' + path1 + '\
' + content1);
});
console.log('end');

这样有 n 个文件同样也都写入数组处理即可。fn1那部分其实就是 CO 的基本原理，但是 CO 是用 Promise 实现的。