ES7的async函数就是Generator函数的语法糖，使得异步操作的流程更加清晰。本篇参照了阮一峰的《ES6标准入门》的async篇幅里的大量内容，这是一本不可多得的好书，建议大家购买学习。你可以从Github上获取本篇例子代码。
仍旧以读取本地文件内容为例，用Generator函数定义依次读取两个文件的异步操作：
var fs = require('fs');
var readFile = function (fileName, options) {
return new Promise(function (resolve, reject){
fs.readFile(fileName, options, function(error, data){
if (error) return reject(error);
resolve(data);
});
});
};
var gen = function* () {
var f1 = yield readFile('./apples.txt', 'utf8');
console.log(f1);
var f2 = yield readFile('./oranges.txt', 'utf8');
console.log(f2);
};
var g = gen();
g.next().value.then(function(data) {
g.next(data).value.then(function(data) {
g.next(data);
});
});
写成async函数，就是下面这样：
var asyncReadFile = async function (){
var f1 = await readFile('./apples.txt', 'utf8');
var f2 = await readFile('./oranges.txt', 'utf8');
console.log(f1);
console.log(f2);
};
asyncReadFile();
先看async函数的定义，和Generator相比语法上来说，将*星号改成了关键字async。将yield改成了await。这主要是为了让其语义上更可读一点。熟悉C++的程序员，看到*星号容易想到函数指针，用关键字async不容易有歧义。另外熟悉Java的程序员，看到yield容易想到暂停线程，用await表示等待异步执行的结果，结合async自动执行的特性，显然await的语义更加贴切。
再看运行，相比Generator一步步next，async的运行可方便多了，上面一行代码搞定。因为async 函数本质上就是将 Generator 函数和自动执行器，包装在一个spawn函数里：
async function fn(args){... }
// 等同于
function fn(args){
return spawn(function*() { ... });
}
所有的async函数都可以写成上面的第二种形式，其中的spawn函数就是自动执行器。实现如下，基本就是co模块的翻版：
function spawn(genF) {
return new Promise(function(resolve, reject) {
var gen = genF();
function step(nextF) {
try {
var next = nextF();
} catch(e) {
return reject(e);
}
if(next.done) {return resolve(next.value); }
Promise.resolve(next.value).then(function(v) {
step(function() { return gen.next(v); });
}, function(e) {
step(function() { return gen.throw(e); });
});
}
step(function() { return gen.next(undefined); });
});
}
自动执行的内容在Generator里有详细介绍。就算不理解也没关系，不影响使用async。
async函数的await命令后面是Promise对象（如果是原始类型的值，会自动将其转成Promise对象并立即将状态设成Resolved，效果等于同步操作）。进一步说，async函数完全可以看作多个异步操作，包装成的一个Promise对象，而await命令就是内部then命令的语法糖。因为await命令后面是Promise对象，需要考虑rejected的情况，毕竟谁也不能断言异步操作中不会出现异常，所以最好把await命令包进try…catch中：
async function myAsyncFun() {
try {
await somePromise();
} catch (err) {
console.log(err);
}
}
//另一种写法
async function myAsyncFun() {
await somePromise().catch(function (err) {console.log(err);});
}
为了提高效率，async函数的await命令间如果不存在依赖关系，即，后一个异步操作不依赖于前一个异步操作的结果的话，可以让这些异步操作并发执行。怎么并发呢？依次写await命令不会并发执行，而是依次执行。要并发可以依赖于await命令后是一个Promise对象的事实，用Promise.all来包装一下，例如：
let [foo, bar] = await Promise.all([getFoo(), getBar()]);
上面这样getFoo和getBar会同时触发执行，可以缩短程序的执行时间。
async函数的返回值是一个Promise对象，这比Generator函数的返回值是Iterator对象方便多了。你可以为其添加then方法：
var f = async function () {
return 'hello world';
}
f().then(v => console.log(v)) // "hello world"
需要注意的是，async函数返回的Promise对象，必须等到内部所有await命令的Promise对象执行完，才会发生状态改变。即async函数内部的异步操作执行完，才会执行返回值的then方法。例如：
var asyncReadFile = async function (){
var f1 = await readFile('./apples.txt', 'utf8');
var f2 = await readFile('./oranges.txt', 'utf8');
var arr = new Array();
arr.push(f1);
arr.push(f2);
return arr;
};
asyncReadFile().then(function(value) {
value.forEach(function(v){
console.log(v);
});
});
上例中等两个异步操作读取完文件内容后，才触发then回调函数。
只要一个await语句后面的Promise变为Rejected状态，那么整个async函数都会中断执行：
var f = async function () {
await Promise.reject('出错了');
return await Promise.resolve('成功了'); // 不会被执行
};
f().then(v => console.log(v))
.catch(e => console.log(e)); //出错了
如果不想一个异步操作出错导致整个async函数中断，可以将await包在try…catch里，这样后续的await就继续被执行：
var f = async function () {
try {
await Promise.reject('出错了');
} catch(e) {
return await Promise.resolve('成功了');
}
};
f().then(v => console.log(v))
.catch(e => console.log(e)); //成功了
另一种方法是await后面的Promise对象再跟一个catch来处理可能出现的异常：
var f = async function () {
await Promise.reject('出错了').catch(e => console.log(e));
return await Promise.resolve('成功了');
};
f().then(v => console.log(v))
.catch(e => console.log(e));
//出错了
//成功了
最后，参照阮一峰《ES6标准入门》的一个例子（几乎照扒原书，请大家支持该书）。来看Async函数与Promise，Generator函数的区别。假定某个DOM元素上面，部署了一系列的动画，前一个动画结束，才能开始后一个。如果当中有一个动画出错，就不再往下执行，返回上一个成功执行的动画的返回值。
首先是Promise的写法。
function chainAnimationsPromise(elem, animations) {
var ret = null; // 变量ret用来保存上一个动画的返回值
var p = Promise.resolve(); // 新建一个空的Promise
for(var anim of animations) { // 使用then方法，添加所有动画
p = p.then(function(val) {
ret = val;
return anim(elem);
});
}
return p.catch(function(e) { // 返回一个部署了错误捕捉机制的Promise
/* 忽略错误，继续执行 */
}).then(function() {
return ret;
});
}
虽然Promise的写法比回调函数的写法大大改进，但是一眼看上去，代码完全都是Promise的API（then、catch等等），操作本身的语义反而不容易看出来。接着是Generator函数的写法：
function chainAnimationsGenerator(elem, animations) {
return spawn(function*() {
var ret = null;
try {
for(var anim of animations) {
ret = yield anim(elem);
}
} catch(e) {
/* 忽略错误，继续执行 */
}
return ret;
});
}
上面代码使用Generator函数遍历了每个动画，语义比Promise写法更清晰，用户定义的操作全部都出现在spawn函数的内部。这个写法的问题在于，必须有一个任务运行器，自动执行Generator函数，上面代码的spawn函数就是自动执行器，它返回一个Promise对象，而且必须保证yield语句后面的表达式，必须返回一个Promise。最后是Async函数的写法：
async function chainAnimationsAsync(elem, animations) {
var ret = null;
try {
for(var anim of animations) {
ret = await anim(elem);
}
} catch(e) {
/* 忽略错误，继续执行 */
}
return ret;
}
可以看到Async函数的实现最简洁，最符合语义，几乎没有语义不相关的代码。它将Generator写法中的自动执行器，改在语言层面提供，不暴露给用户，因此代码量最少。如果使用Generator写法，自动执行器需要用户自己提供。
