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写法，自动执行器需要用户自己提供。