假设一个场景，需要读取两个文件，然后把两个文件的内容倒序合并后输出，而且不能阻塞进程。
直接用回调来实现
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）。
使用 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实现
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 实现的。
