上个寒假又又又···不知道第几遍重温ES6，以下对几个异步实现写个总结。
在之前，我们最常见的异步实现莫过于回调函数，但是如果嵌套太深，代码就会变得难以阅读与维护。而在ES6中，我们有了更多更加优美的异步实现方式，正因如此，我们才得以走出回调地狱。
Promise
Promise是异步编程的一种优良的解决方案，它比传统的回调更加合理。在ES6中，Promise是一个对象，它有三种状态：进行中(pending)、已成功（resolved)、已失败（rejected)。所以Promise可能的改变就只有两种，从进行中转变到已成功或者从进行中转变到失败，并且一旦状态发生改变，之后便会一直保持这个状态，不会也无法改变。
基础用法
let promise = new Promise(function(resolve, reject) {
resolve('successed');
})
promise.then(function(data) {
console.log(data);
}, function(err) {
console.log(err);
})
//'successed'
Promise的构造函数接收一个带有两个参数的函数，这两个参数分别是Promise的状态改变为成功和失败的函数，然后使用then方法分别设置状态变为成功和失败后的操作。
resolve和reject函数都可以接受一个参数，这个参数传递会给then方法，所以上面代码，当resolve函数把promise的状态变成已成功之后，会把它的参数“successed”传递给then方法，因此最后then方法会把这个字符串打印出来。
下面我们再写一个读取文件的Promise
//ES5的写法
var fs = require('fs');
fs.readFile('./a.txt', function(err, data) {
console.log(data.toString('utf8'));
fs.readFile('./b.txt', function(err, data) {
console.log(data.toString());
fs.readFile('./c.txt', function(err, data) {
console.log(data.toString());
});
});
})
//ES6的写法
function returnFilePromise(fileName) {
return promise = new Promise((resolve, reject) => {
fs.readFile(fileName, function(err, data) {
if (!err) {
resolve(data);
} else {
reject(err);
}
});
})
}
let promise = returnFilePromise('./a.txt');
promise
.then(function(data) {
console.log(data.toString());
return returnFilePromise('./b.txt');
})
.then(function (data) {
console.log(data.toString());
return returnFilePromise('./c.txt');
})
.then(function (data) {
console.log(data.toString());
})
.catch(function (err) {
console.log(err);
})
上面两段代码的功能一样，都是继发异步读取三个文件，但是我们可以看到，用回调函数来写，则会出现多层嵌套，使得代码很难看，要是嵌套层数更多的话，代码的可读性和可维护性就会变得很差。而Promise却可以采用链式写法（因为then可以返回一个新的Promise），整个过程非常直观，最后的一个catch方法可以捕捉到前面三个then方法抛出的错误。
当然，Promise的魅力远不止这些，它还有很多有趣的方法比如finally方法、all方法和race方法等等。
Generator
基础用法
Generator函数是ES6中另一种异步编程方式，它会返回一个遍历器对象。Generator有三个跟其他函数不一样的地方：函数名带星号（*），函数内部的yield表达式和next调用函数方法。
function * g () {
console.log(0);
yield 1;
yield 2;
console.log(666);
yield 3;
return 4;
yield 5;
}
var ge = g();
ge.next();
ge.next();
ge.next();
ge.next();
ge.next();
//0
//{ value: 1, done: false }
//{ value: 2, done: false }
//666
//{ value: 3, done: false }
//{ value: 4, done: false }
//{ value: undefined, done: true }
由上面的代码可以清楚地看到，我们每调用一次遍历器对象next方法，函数就会执行一次，直到遇到并执行完一个yield表达式，函数就会暂停下来，并保留这个状态，再调用一次next方法，函数会从上次停下来的地方接着执行下去，直到执行一个yield表达式后，又停下来，等待下一个next方法。当遇到return时，整个函数执行完毕，即使后面还有yield表达式也不会执行。
next方法返回的是一个有两个属性的对象，第一个属性是yield后面的值，第二个属性是表示Generator函数是否执行完毕，当done属性为true是则表示函数已经执行完毕了。
next方法可以带一个参数，这个参数代表上一个yield的返回值
//不带参数
function * g () {
var a = yield 1;
console.log(a);
}
var ge = g();
console.log(ge.next())
console.log(ge.next())
//{ value: 1, done: false }
//undefined
//{ value: undefined, done: true }
//带参数
function * g () {
var a = yield 1;
console.log(a);
}
var ge = g();
console.log(ge.next())
console.log(ge.next(1))
//{ value: 1, done: false }
//1
//{ value: undefined, done: true }
如果next不带参数的话，那么上一个yield的返回值是undefined。
有了next带参数这个功能，我们就可以在函数运行之后，还能向函数体内输入值，用以调整函数行为。
当yield太多时，手动next未免太麻烦，这时可以用for of循环来一次性执行
function* g() {
yield 1;
yield 2;
yield 3;
}
for (let n of g()) {
console.log(n);
}
// 1 2 3
Generator的异步使用
先简单介绍一下协程。多个函数并行执行，但是只能有一个函数处于运行状态，其它函数处于暂停状态，各个函数之间可以交换函数执行权。从内存上看，协程有多个函数栈，但是只有一个栈处于运行状态，这是一种以牺牲内存来实现多任务并行的方法。也正是因为Generator可以交出和收回执行权，所以它很适合处理异步
let returnFilePromise = (fileName) => {
return new Promise((resolve, reject) => {
fs.readFile(fileName, function(err, data) {
if (!err) {
resolve(data);
} else {
reject(err);
}
})
})
}
function * readFiles () {
yield returnFilePromise('./a.txt');
yield returnFilePromise('./b.txt');
yield returnFilePromise('./c.txt');
}
let ge = readFiles();
function gogogo (fn) {
let result = fn.next()
if (!result.done) {
result.value.then(function (data) {
gogogo(fn);
console.log(data.toString())
})
}
}
gogogo(ge);
//This is A
//This is B
//This is C
上面依旧是一个读取三个文件的异步代码（读取完a.txt后再读取b.txt），用Generator写起来的感觉特别像是在写同步代码，实际上他是异步执行的，这里我们另外写了一个让Generator可以自动执行的函数，每个yield返回值都是一个Promise，实际上，Generator经常会使用到Promise。
为了便于管理Generator函数，除了使每个yield函数返回Promise外，我们也可以利用Thunk函数做到这一点。
Thunk函数
一般来说，Thunk函数是一种“传名调用”的实现方法
var a = 1
function fn (n) {
console.log(n);
}
fn(a + 1); //相当于fn(2), 参数在进入函数体之前求值，传值调用
//使用Thunk函数
function fn (th) {
console.log(th());
}
function thunk () {
return a + 1;
}
fn(thunk) //传名调用
在JS中，Thunk函数会用来把一个多参数的函数变成值接受一个回调函数为参数的单参数函数，任何有回调函数作参数的函数都可以写成Thunk函数的形式。
let thunk = function(fn) {
return function (...args) {
return function (callback) {
return fn.call(this, ...args, callback);
}
}
}
在实际生产开发时，一般会用thunkify模块来进行转化，相关模块的具体使用这里不再赘述。
async函数
async函数是Generator的语法糖，使得异步操作变得更加方便和语义化。并且它可以跟普通函数一样调用执行（自带执行器），而不需要像Generator那样部署执行器。
let myAsync = async function () {
let a = await returnFilePromise('./a.txt');
let b = await returnFilePromise('./b.txt');
let c = await returnFilePromise('./c.txt');
console.log(a.toString());
console.log(b.toString());
console.log(c.toString());
return c.toString();
}
myAsync().then(data => console.log(data.toString()))
//This is A
//This is B
//This is C
//This is C
await后面接的是Promise，当然也可以是原始类型的值，但就变成了同步操作（转化成Promise后立即执行resolve()）。整个async函数的返回值是一个Promise，因此可以在函数调用后使用then方法，函数体内的return的返回值会当做then的回调函数的参数。
await会按代码书写的顺序执行，在上面代码中，必须等a.txt读取完毕，下一个await才会执行，也就是说，在await函数体内，await表达式是同步的。但是整个async函数是异步的。如果多个异步操作之间不存在继发关系，这样的等待未免多余，我们可以用Promise.all方法把多个异步操作放在一起。
await的返回值是它后面Promise中resolve或者reject的参数，其中reject的参数会被catch方法捕获，不管有没有写return。只要有一个await的Promise的状态变为reject，那么整个async函数就会中断执行(async返回的Promise的状态变为reject)，如果我们希望有一个异步操作的成功与否不影响其他操作，那么我们可以把它放在try···catch中。
async function getErr() {
try {
await Promise.reject("error");
} catch (e) {
console.log(e);
}
return await returnFilePromise('./a.txt');
}
getErr().then(data => console.log(data.toString()))
//error
//This is A
或者稍微暴力一点，直接在那个Promise后面接一个catch方法来捕获错误
async function getErr() {
await Promise.reject("error")
.catch(e => console.log(e));
return await returnFilePromise('./a.txt');
}
getErr().then(data => console.log(data.toString()));
最后
Promise确实是个好东西，Generator和async函数都用到了它。虽然在ES6之前就已经有了Promise，但是直到ES6才被写进标准，并大放异彩。
还有一件事，我偷懒了没好好写前两部分的错误处理，哈哈哈哈哈哈～
