上一篇 Promise 讲述了用Promise来解决回调带来的多嵌套，可读性差的问题。其中有这段话

最理想的方式当然是这样

readFile(a,funcA);
readFile(b,funcB);
readFile(c,funcC);
readFile(d,funcD);

但是他不能保证读完A文件后才读B。

结果ES6又帮你做到了，你不再需要通过添加回调来欺骗自己不能按顺序书写的短处。现在你可以堂堂正正的从上而下写代码。

语法

async函数返回一个 Promise 对象，可以使用then方法添加回调函数。当函数执行的时候，一旦遇到await就会先返回，等到异步操作完成，再接着执行函数体内后面的语句。

async function print(){
    return 1;
}
print().then(e => console.log(e));   //1

async函数内部return语句返回的值，会成为then方法回调函数的参数。
回到上一篇的例子

function readFile(a){
    return new Promise(resolve=>{
          setTimeout(()=>{
              console.log(a);
              resolve(a);
          },500)
    })
}

readFile('a')
.then(()=>{
   console.log('b')
})
.then(()=>{
    console.log('c')
});     //a b c

现在可以写成这样了

async function test(){
  await readFile('a'); 
  console.log('b');
  console.log('c')
}
test();   //a b c

它依旧会按顺序打出a b c。因为async函数执行的时候，遇到await，就会等待readFile函数先完成，再执行后面的代码。这种写法更为简洁，几乎和同步代码的写法一致。语义化很好，就算你没学过这个语法，看到await，也会觉得函数会等待readFile返回结果。
再写个测试代码：

async function test(){
  await readFile('a'); 
  console.log('b');
  console.log('c')
}
test(); 
console.log('d');   //d a b c

d的打印没有被await阻塞住，先打印了d。await只会影响async函数内部的执行顺序。

实现原理

肯定有人会好奇async是怎样的实现原理，想要理解它，还是得学习生成器（generator）。毕竟async只是generator的语法糖，跳过它直接学习async当然会错过很多。async 就等于Generator+自动执行器。

Generator

var x = 1;
function *foo(){
  x++;
  yield 'hello';
  x++;
  console.log(x);
}
var  it = foo();

这里并没有打出理想的3。生成器*foo()没有像普通函数一样运行，它只是创建了一个迭代器。

it.next();  //{value：'hello',done:false} 
console.log(x);   //2
it.next();  //3   {value：undefined,done:true}

第一次调用next(),会从函数开始位置执行到第一个暂停点(yield处)。它返回了一个对象，对象的value值就是当前yield的值。此时执行了一次x++;所以x的值为2。再次执行next()会运行到函数结束。这种方式可以让函数体的代码分段执行。而不再是一调用函数就自动帮你从到尾执行完，需要你手动next()来控制代码的进度。所以用它来处理异步的方式也比较明了了。yield暂停函数体代码，当异步操作完成后再使用next()恢复函数的代码。

function readFile(a){
    return new Promise(resolve=>{
          setTimeout(()=>{
              console.log(a);
              resolve(a);
          },500)
    })
}
function *foo(){
  var result = yield readFile('a');
  console.log('b');
}
var it = foo();
var result = it.next();  //next返回的value是readFile函数返回的Promise对象
result.value.then(()=>{   //给Promise对象增加成功的回调
  it.next();   //当Promise成功后恢复foo()函数执行
});  //a b

按顺序打出了a和b。很好理解，执行到readFile的时候暂停了foo函数，直到Promise被解决后调用了next()，才恢复了函数.。虽然foo()函数内部好看了，但是想要控制foo函数的暂停和继续却需要写额外的代码。所以如果有人能帮忙控制就最好不过了，不然我宁愿用Promise。

自动执行器

浏览器可不会帮你管理生成器，你得自己写。可以看到，it.next()返回{value:x,done:false}。根据done的值是可以知道生成器内部代码是否执行完成。那根据他写个递归出来不就美滋滋了。试试。

function run(g){
  var res = g.next();
  if(!res.done){
    run(g);
  }
}

不对，异步操作还没返回结果，就被你继续执行了。还得改改

function run(g){
  var res = g.next(); //记住res.value是个promise对象
  if(!res.done){
    res.value.then(()=>{   //promise解决了才调用next()继续执行生成器内部函数
      run(g);
    })  
  }
}

测试一波

function readFile(a){
    return new Promise(resolve=>{
          setTimeout(()=>{
              console.log(a);
              resolve(a);
          },500)
    })
}
function *foo(){
  console.log('a')；
  var result = yield readFile('b');
  console.log('c');
}
function run(g){
  var res = g.next(); //记住res.value是个promise对象
  if(!res.done){
    res.value.then(()=>{   //promise解决了才继续执行生成器内部函数
      run(g);
    })  
  }
}
run(foo()); 
console.log('d');

打出了a d b c。完美！第一次执行foo().next()会打印出a。然后生成器内函数暂停。在打出d。定时器到了后再打出b和c。这个简单的自动执行器，是针对yield后面跟着promise对象的情况。实际使用可能不能这么写，它只是帮助你理解。实战可以选择co模块。
async 等于Generator+自动执行器，现在应该很好理解了。

async function test(){};test();
//等价于
run((function *test(){})());