ES6学习笔记——async

含义

-ES2017 标准引入了 async 函数，使得异步操作变得更加方便。

async 函数是什么？ 一句话，它就是 Generator 函数的语法糖。

一比较就会发现，async函数就是将 Generator 函数的星号（*）替换成async，将yield替换成await，仅此而已。

async函数对 Generator 函数的改进，体现在以下四点。

（1）内置执行器。

Generator 函数的执行必须靠执行器，所以才有了co模块，而async函数自带执行器。也就是说，async函数的执行，与普通函数一模一样，只要一行。这完全不像 Generator 函数，需要调用next方法，或者用co模块，才能真正执行，得到最后结果。

（2）更好的语义。

async和await，比起星号和yield，语义更清楚了。async表示函数里有异步操作，await表示紧跟在后面的表达式需要等待结果。

（3）更广的适用性。

co模块约定，yield命令后面只能是 Thunk 函数或 Promise 对象，而async函数的await命令后面，可以是 Promise 对象和原始类型的值（数值、字符串和布尔值，但这时等同于同步操作）。

（4）返回值是 Promise。

async函数的返回值是 Promise 对象，这比 Generator 函数的返回值是 Iterator 对象方便多了。你可以用then方法指定下一步的操作。

进一步说，async函数完全可以看作多个异步操作，包装成的一个 Promise 对象，而await命令就是内部then命令的语法糖。

基本用法

栗子君来也：

function timeOut(ms) {
       return new Promise(resolve => {
           setTimeout(resolve, ms);
       })
   }
   async function asyncPrint(value, ms) {
       await timeOut(ms);
       console.log(value);
   }
   asyncPrint('hello world', 5000);

这个例子就是5秒之后在控制台出现hello world。 那如果去掉async函数呢？

function timeOut(ms) {
       return new Promise(resolve => {
           setTimeout(resolve, ms);
       })
   }
   function asyncPrint(value, ms) {
       timeOut(ms);
       console.log(value);
   }
   asyncPrint('hello world', 5000);

当然是没有延迟5秒就会直接在控制塔输出hello world咯！

由于async函数返回的是 Promise 对象，可以作为await命令的参数。所以，上面的例子也可以写成下面的形式。

async function timeOut(ms) {
       return await new Promise(resolve => {
            setTimeout(resolve, ms);
       })
   }
   async function asyncPrint(value, ms) {
       await timeOut(ms);
       console.log(value);
   }
   asyncPrint('hello hui', 5000);

语法

async函数的语法规则总体上比较简单，难点是错误处理机制。

返回 Promise 对象

async函数返回一个 Promise 对象。

async函数内部return语句返回的值，会成为then方法回调函数的参数。

async function f() {
       return 'hello world';
   }
   f().then(v => console.log(v));

上面代码中，函数f内部return命令返回的值，会被then方法回调函数接收到。

async函数内部抛出错误，会导致返回的 Promise 对象变为reject状态。抛出的错误对象会被catch方法回调函数接收到。

async function f1() {
       throw new Error('error');
   }
   f1().then(
       v => console.log(v),
       e => console.log(e)
   )

Promise 对象的状态变化

async函数返回的 Promise 对象，必须等到内部所有await命令后面的 Promise 对象执行完，才会发生状态改变，除非遇到return语句或者抛出错误。也就是说，只有async函数内部的异步操作执行完，才会执行then方法指定的回调函数。

async function getTitle(url) {
       let response = await fetch(url);
       let html = await response.text();
       return html.match(/<title>([\s\S]+)<\/title>/i)[1];
   }
getTitle('https://tc39.github.io/ecma262/').then(console.log);

await命令

正常情况下，await命令后面是一个 Promise 对象，返回该对象的结果。如果不是 Promise 对象，就直接返回对应的值。

async function f() {
       return await 1234;
   }
   f().then(v => console.log(v));

上面的例子直接返回1234。

另一种情况是，await命令后面是一个thenable对象（即定义then方法的对象），那么await会将其等同于 Promise 对象。

class Sleep {
       constructor(timeout) {
           this.timeout = timeout;
       }
       then(resolve, reject) {
           const startTime = Date.now();
           setTimeout(() => {
               resolve(Date.now() - startTime),
                   this.timeout
           })
       }
   }
   (async () => {
       const actualTime = await new Sleep(1000);
       console.log(actualTime);
   })();

上面代码中，await命令后面是一个Sleep对象的实例。这个实例不是 Promise 对象，但是因为定义了then方法，await会将其视为Promise处理。

await命令后面的 Promise对象如果变为reject状态，则reject的参数会被catch方法的回调函数接收到。

async function f() {
       await Promise.reject('出错了');
   }
   f().then(v => console.log(v))
       .catch(e => console.log(e))

注意，上面代码中，await语句前面没有return，但是reject方法的参数依然传入了catch方法的回调函数。这里如果在await前面加上return，效果是一样的。

任何一个await语句后面的 Promise对象变为reject状态，那么整个async函数都会中断执行。

async function f() {
       await Promise.reject('出错了111');
       await Promise.resolve('hello world');
}
f();

上例中的第二个语句不会执行，因为因为第一个await语句状态变成了reject。

有时，我们希望即使前一个异步操作失败，也不要中断后面的异步操作。这时可以将第一个await放在try...catch结构里面，这样不管这个异步操作是否成功，第二个await都会执行。

async function f() {
       try {
           await Promise.reject('出错了123');
       }  catch (e) {
           return await Promise.resolve('hello world')
       }
}
f().then(v => console.log(v));

另一种方法是await后面的 Promise 对象再跟一个catch方法，处理前面可能出现的错误。

async function f() {
       await Promise.reject('出错了2333').catch(e => console.log(e));
       return await Promise.resolve('hello world');
}
f().then(v => console.log(v));

使用注意点

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

下面这段代码就是按照顺序执行的（即继发关系）：

function getFoo() {
   return new Promise(() => {
       setTimeout(() => {
           console.log('getFoo');
           console.log(new Date());
       }, 2000);
   });
}
function getBar() {
   return new Promise(() => {
       setTimeout(() => {
           console.log('getBar');
           console.log(new Date());
       }, 2000);
   });
}
async function f() {
   // 按顺序运行
   var foo = await getFoo();
   var bar = await getBar();
}
f();

函数运行后2s，输出'getFoo'，再2s后输出'getBar'。

以下两种写法，getFoo和getBar都是同时触发，这样就会缩短程序的执行时间。

function getFoo() {
   return new Promise(() => {
       setTimeout(() => {
           console.log('getFoo');
           console.log(new Date());
       }, 2000);
   });
}
function getBar() {
   return new Promise(() => {
       setTimeout(() => {
           console.log('getBar');
           console.log(new Date());
       }, 2000);
   });
}
async function f1() {
   // 同时触发写法一
   // let [foo, bar] = await Promise.all([getFoo(), getBar()]);

   // 同时触发写法二
   let fooPromise = getFoo();
   let barPromise = getBar();
   let foo = await fooPromise;
   let bar = await barPromise;
}
f();

以上两种写法，2s后，'getFoo'和'getBar'同时输出。

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

但是如果将forEach方法的参数改成async函数，也有问题。

function f() {
  return new Promise(resolve => {
      setTimeout(() => {
          resolve(console.log(new Date().getSeconds()))
      }, 1000);
  });
}

function f1() {
   let docs = [{}, {}, {}];
   docs.forEach(async function(doc) {
       await f(doc);
   });
}
f1();   // 并发执行
// 33 33 33(33s时运行，得到三个33)

上面代码结果为三个相同的值，原因是这时三个f(doc)操作是并发执行，也就是同时执行，而不是继发执行。正确的写法是采用for循环。

function f() {
  return new Promise(resolve => {
      setTimeout(() => {
          resolve(console.log(new Date().getSeconds()))
      }, 1000);
  });
}

async function f2() {
   let docs = [{}, {}, {}];
   for (let doc of docs) {
       await f(doc);
   }
}
f2();  // 继发执行
// 33 34 35 （33s时运行，得到三个不同的值）

最后，留一个小测试：

async function async1() {
  console.log('async1 start');
  await async2();
  console.log('async1 end');
}
async function async2() {
  console.log('async2');
}
console.log('script start');
setTimeout(() => {
  console.log('setTimeout');
}, 0);
async1();
new Promise(resolve => {
      console.log('promise1');
      resolve();
}).then(() => {
  console.log('promise2');
});
console.log('script end');

答案是什么呢?正确答案在下方哟！！

// script start
// async1 start
// async2
// promise1
// script end
// promise2
// async1 end
// setTimeout