06.ES6之async函数

1.基本用法

async函数返回一个Promise对象，可以用then方法添加回调函数，async和await配合使用。

async函数有多种使用形式：

// 函数声明
async function foo() {}

// 函数表达式
const foo = async function () {};

// 对象的方法
let obj = { async foo() {} };
obj.foo().then(...)

// Class 的方法
class Storage {
  constructor() {
    this.cachePromise = caches.open('avatars');
  }

  async getAvatar(name) {
    const cache = await this.cachePromise;
    return cache.match(`/avatars/${name}.jpg`);
  }
}

const storage = new Storage();
storage.getAvatar('jake').then(…);

// 箭头函数
const foo = async () => {};

2.语法

（1）返回Promise对象

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

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

f().then(v => console.log(v))
// "hello world"

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

async function f() {
  throw new Error('出错了');
}

f().then(
  v => console.log(v),
  e => console.log(e)
)
// Error: 出错了

（2）Promise对象的状态变化

只有async函数内部的异步操作执行完，才会执行then方法指定的回调函数

（3）await命令

await命令后是一个Promise对象，返回该对象的结果，如果不是Promise对象，就直接返回对应的值

async function f() {
  // 等同于
  // return 123;
  return await 123;
}

f().then(v => console.log(v))
// 123

await命令后是一个thenable对象（定义了then方法的对象），await会将其等同于Promise对象 

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

async function f() {
  await Promise.reject('出错了');
  await Promise.resolve('hello world'); // 不会执行
}

如果希望即使前一个异步操作失败，也不要中断后边的异步操作，这时可以将第一个await放在try...catch结构里。

async function f() {
  try {
    await Promise.reject('出错了');
  } catch(e) {
  }
  return await Promise.resolve('hello world');
}

f()
.then(v => console.log(v))
// hello worl

也可以在await后边的promise对象后再跟一个catch方法，处理前边可能出现的错误。

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

f()
.then(v => console.log(v))
// 出错了
// hello world

（4）错误处理

如果await后面的异步操作出错，那么等同于async函数返回的 Promise 对象被reject。

async function f() {
  await new Promise(function (resolve, reject) {
    throw new Error('出错了');
  });
}

f()
.then(v => console.log(v))
.catch(e => console.log(e))
// Error：出错了

防止出错的方法，也是将其放在try...catch代码块之中。

async function f() {
  try {
    await new Promise(function (resolve, reject) {
      throw new Error('出错了');
    });
  } catch(e) {
  }
  return await('hello world');
}

下面的例子使用try...catch结构，实现多次重复尝试。

如果await操作成功，就会使用break语句退出循环；如果失败，会被catch语句捕捉，然后进入下一轮循环。

const superagent = require('superagent');
const NUM_RETRIES = 3;

async function test() {
  let i;
  for (i = 0; i < NUM_RETRIES; ++i) {
    try {
      await superagent.get('http://google.com/this-throws-an-error');
      break;
    } catch(err) {}
  }
  console.log(i); // 3
}

test();

（5）使用注意点

  5.1  await命令后面的Promise对象，运行结果可能是rejected，所以最好把await命令放在try...catch代码块中。

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

//不存在依赖 但被写成继发模式
let foo = await getFoo();
let bar = await getBar();

//让他们同时触发

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

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

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

async function dbFuc(db) {
  let docs = [{}, {}, {}];

  // 报错
  docs.forEach(function (doc) {
    await db.post(doc);
  });
}

//可以这样写：
async function dbFuc(db) {
  let docs = [{}, {}, {}];

  for (let doc of docs) {
    await db.post(doc);
  }
}

5.4  async 函数可以保留运行堆栈。

const a = () => {
  b().then(() => c());
};

上边代码中，函数a内部运行了一个异步任务b()。当b()运行的时候，函数a()不会中断，而是继续执行

等到b()运行结束，可能a()早就运行结束了，b()所在的上下文环境已经消失了。如果b()或c()报错，错误堆栈将不包括a()

如果改成async函数：

const a = async () => {
  await b();
  c();
};

上面代码中，b()运行的时候，a()是暂停执行，上下文环境都保存着。一旦b()或c()报错，错误堆栈将包括a()

（6）async函数的实现原理

async函数的实现原理，就是将Generator函数和自动执行器包装在一个函数里

async function fn(args){
    ...
}
//等同于
function fn(args){
    return spawn(function* () {
        ...
    });
}

spawn函数是自动执行器。

注：await命令只能放在async函数内部，否则报错。