1.async语法

async函数自带执行器。async函数的执行，与普通函数一模一样
await表示紧跟在后面的表达式需要等待结果
yield命令后面只能是 Thunk 函数或 Promise 对象，async函数的await命令后面，可以是Promise 对象和原始类型的值（数值、字符串和布尔值，但这时等同于同步操作）。
generator返回值为iterator，async返回值是promise

2.用法

当函数执行的时候，一旦遇到await就会先返回，等到异步操作完成，再接着执行函数体内后面的语句。
指定50毫秒以后，输出hello world

     function timeout(ms) {
        return new Promise((resolve) => {
           setTimeout(resolve, ms);
        });
     }

    async function asyncPrint(value, ms) {
       await timeout(ms);
       console.log(value);
    }

    asyncPrint('hello world', 50);

3.语法

返回promise对象。async内部返回只会作为then方法回调函数的参数

async function f() {
return 'hello world';
}

f().then(v => console.log(v))
// "hello world"
async函数内部抛出错误，会导致返回的 Promise 对象变为reject状态。抛出的错误对象会被catch方法回调函数接收到。
async函数返回的 Promise 对象，必须等到内部所有await命令后面的 Promise 对象执行完，才会发生状态改变，除非遇到return语句或者抛出错误。
await
await命令后面是一个 Promise 对象。如果不是，会被转成一个立即resolve的 Promise 对象。
await命令后面的 Promise 对象如果变为reject状态，则reject的参数会被catch方法的回调函数接收到。只要一个await语句后面的 Promise 变为reject，那么整个async函数都会中断执行。
不中断异步错误的方法
使用async中使用try-catch块
处理await后的promise。promise后面加上catch处理

4.注意点

多个await命令后面的异步操作，如果不存在继发关系，最好让它们同时触发。

  // 写法一
 let [foo, bar] = await Promise.all([getFoo(), getBar()]);

 // 写法二
let fooPromise = getFoo();
let barPromise = getBar();
let foo = await fooPromise;
let bar = await barPromise;

await命令只能用在async函数之中，如果用在普通函数，就会报错。

5.按顺序实现异步操作

依次远程读取一组 URL，然后按照读取的顺序输出结果。
promise方式

function logInOrder(urls) {
  // 远程读取所有URL
  const textPromises = urls.map(url => {
    return fetch(url).then(response => response.text());
  });

 // 按次序输出   通过reduce形成promise链
 textPromises.reduce((chain, textPromise) => {
     return chain.then(() => textPromise)
        .then(text => console.log(text));
     }, Promise.resolve());
  }

async并发实现

 async function logInOrder(urls) {
   // 并发读取远程URL
     const textPromises = urls.map(async url => {
     const response = await fetch(url);
     return response.text();
   });

    // 按次序输出
   for (const textPromise of textPromises) {
       console.log(await textPromise);
   }
 }

总结：array.map(callback)实现并发操作

6.异步遍历器

问题：iterator遍历器中，next方法必须是同步的，只要调用就必须立刻返回值。也就是说，一旦执行next方法，就必须同步地得到value和done这两个属性。如果遍历指针正好指向同步操作，当然没有问题，但对于异步操作，就不太合适了。
异步遍历器

调用遍历器的next方法，返回的是一个 Promise 对象。
可以使用then方法指定，这个 Promise 对象的状态变为resolve以后的回调函数。

回调函数的参数，则是一个具有value和done两个属性的对象。

 asyncIterator
   .next()
   .then(
       ({ value, done }) => /* ... */
  );

异步遍历器其实返回了两次值。第一次调用的时候，返回一个 Promise 对象；等到 Promise 对象resolve了，再返回一个表示当前数据成员信息的对象。这就是说，异步遍历器与同步遍历器最终行为是一致的，只是会先返回 Promise 对象，作为中介。

异步遍历器的next方法是可以连续调用的，不必等到上一步产生的Promise对象resolve以后再调用。这种情况下，next方法会累积起来，自动按照每一步的顺序运行下去。

使用promise.all()

const asyncGenObj = createAsyncIterable(['a', 'b']);
const [{value: v1}, {value: v2}] = await Promise.all([
   asyncGenObj.next(), asyncGenObj.next()
]);

console.log(v1, v2); // a b

连续调用next，最后用await同意处理

const writer = openFile('someFile.txt');
writer.next('hello');
writer.next('world');
await writer.return();

7.遍历异步的iterator接口 for await-of

异步遍历器部署在Symbol.iterator上，异步几口部署在Symbol.asyncIterator上。
示例，其中req是asyncIterable 对象。如果next方法返回的 Promise 对象被reject，for await...of就会报错，要用try...catch捕捉。
```
 let body = '';

 async function f() {
 for await(const data of req) body += data;
    const parsed = JSON.parse(body);
    console.log('got', parsed);
}
```

8.异步Generator函数

异步 Generator 函数就是async函数与 Generator 函数的结合
例1：

   async function* gen() {
      yield 'hello';
    }
   const genObj = gen();
   genObj.next().then(x => console.log(x));
   // { value: 'hello', done: false }

例2：

     async function* readLines(path) {
       let file = await fileOpen(path);

       try {
         while (!file.EOF) {
           yield await file.readLine();
         }
      } finally {
        await file.close();
      }
   }

await命令用于将外部操作产生的值输入函数内部，yield命令用于将函数内部的值输出
yield 后接异步遍历器*

      async function* gen1() {
         yield 'a';
         yield 'b';
         return 2;
       }

       async function* gen2() {
            // result 最终会等于 2
       const result = yield* gen1();
        }

使用for await-of循环，会展开gen1中的yield

 (async function () {
     for await (const x of gen2()) {
     console.log(x);
     }
   })();
  // a
  // b

async函数