上次我们大概说了一下 Promise ，今天就接着讲 async/await 这组 API 。

async/await 是 ES7 的标准，Promise 是 ES6 标准，async/await 这套 API 也是用来帮助我们写异步代码的，它是构建在 Promise 之上的，有点像 Okhttp 和 Retrofit 的关系。

什么是 async ？

async function myFirstAsyncFunction() {
  try {
    const fulfilledValue = await doSomeThing();
  }
  catch (rejectedValue) {
    // …
  }
}

大概长上面这个样子。async 一般不单独使用，而是和 await 一起使用，一个 async 函数内部可能有零个或者多个 await 。

这段代码即使没有学过 Promise 也很容易看懂。这就是 async 函数的优势所在。

async 函数被调用的时候，会立即返回一个 Promise。

await

await 不能单独使用，如果在非 async 函数内部被调用会报错。await 后面一般跟一个 Promise ，也可以是其他的，比如一个数值，或者一个变量，或者一个函数。如果 await 后面不是一个 Promise 就会返回一个已经 resolve 的 Promise。

当 async 函数执行到 await 的时候，会暂停整个async函数的执行进程并出让其控制权，只有当其等待的基于Promise 的异步操作被兑现或被拒绝之后才会恢复进程。

当然，async 函数也会返回一个 Promise ，也就是说，await 后面也可以跟一个 async 函数。

async/await 这套 API ，感觉有 Kotlin 中的协程和挂起函数内味。

为什么要使用 async ？

隐藏 Promise ，更易于理解

假设我们想请求一个接口，然后把响应的数据打印出来，并且捕获异常。用 Promise 大概是这样写：

function logFetch(url) {
  return fetch(url)
    .then(response => response.text())
    .then(text => {
      console.log(text);
    }).catch(err => {
      console.error('fetch failed', err);
    });
}

如果用 async 函数来写，大概是这个样子：

async function logFetch(url) {
  try {
    const response = await fetch(url);
    console.log(await response.text());
  }
  catch (err) {
    console.log('fetch failed', err);
  }
}

虽然代码的行数差不多，但是代码看起来更加简洁，少了很多 then 的嵌套。请求一个接口数据，然后打印，就像你看到的，很简单。

就像刚才的那个例子，如果没学过 Promise 也不影响你看懂和理解 async 代码。这个好像没什么，但是对于一个大型的项目，人员的技术水平参差不齐，不能保证所有人都熟悉和理解 Promise ，我们要做的是尽可能的降低代码的理解难度，使大部分人都能看懂。

用同步的思路写异步逻辑

async/await 最大的优势就是我们可以用同步的思路来写异步的业务逻辑，所以代码整体看起来更加容易看懂。我们举个例子。

上面的代码还是比较简单，我们再举一个复杂一点的例子。

我们想获取一个网络资源的大小，如果使用 Promise 大概可能是这个样子：

function getResponseSize(url) {
  return fetch(url).then(response => {
    const reader = response.body.getReader();
    let total = 0;

    return reader.read().then(function processResult(result) {
      if (result.done) return total;

      const value = result.value;
      total += value.length;
      console.log('Received chunk', value);

      return reader.read().then(processResult);
    })
  });
}

即使你学过 Promise ，这个代码也并不是很好理解，更别说是没有学过 Promise 的同学了。因为中间有一个循环的过程，而且这个执行的过程的异步的，并不想我们之前学到的一个链式调用能解决的。当然，你也可以抽取一下，使代码更简洁一点。

const processResult = (result) =>{
      if (result.done) return total;

      const value = result.value;
      total += value.length;
      console.log('Received chunk', value);

      return reader.read().then(processResult);
}

function getResponseSize(url) {
  return fetch(url).then(response => {
    const reader = response.body.getReader();
    let total = 0;

    return reader.read().then(processResult)
  });
}

但是多了一个方法，勉勉强强吧。但是我们看一下 async 函数是怎么处理的。

async function getResponseSize(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();
  let result = await reader.read();
  let total = 0;

  while (!result.done) {
    const value = result.value;
    total += value.length;
    console.log('Received chunk', value);
    // get the next result
    result = await reader.read();
  }

  return total;
}

OHHHHHHHHH

这个是不是看起来就更加流畅了？因为 await 表达式会阻塞运行，甚至可以直接阻塞循环，所以整体看起来像同步的代码，也更符合直觉，更容易读懂这个代码。

小心 await 阻塞

由于 await 能够阻塞 async 函数的运行，所以代码看起来更像同步的代码，更容易阅读和理解。但是要小心 await 阻塞，因为有些阻塞是不必要的，不恰当使用可能会影响代码的性能。

假如我们要把一个网络数据和本地数据合并，错误的实例可能是这样子：

async function combineData(url, file) {
    let networkData = await fetch(url)
    let fileData = await readeFile(file)
    console.log(networkData + fileData)
}

其实我们不用等一个文件读完了，再去读下个文件，我们可以两个文件一起读，读完之后再进行合并，这样能提高代码的运行速度。我们可以这样写：

async function combineData(url, file) {
  	let fetchPromise = fetch(url)
    let readFilePromise = readFile(file)
    let networkData = await fetchPromise
    let fileData = await readFilePromise
    console.log(networkData + fileData)
}

这样的话，就可以同时网络请求和读取文件了，可以节省很多时间。这里主要是利用了 Promise 一旦创建就立刻执行的特点，不懂的同学可以复习一下上一节的内容。

当然，如果你熟悉 Promise 的话，可以直接使用 Promise.all 的方式来处理，或者 await 后面跟 Promise.all 这里就不展开讲了。

异常处理

try...catch

在 async 函数中，异常处理一般是 try...catch ，如果没有进行 try...catch ，await 表达式一旦 reject ，async 函数返回的 Promise 就会 reject 。

其实结合 Promise 来看，如果一个 Promise 状态敲定为 reject ，并且后续的 then 没有传入 reject 函数，或者没有 catch ，那么就会抛出异常。从这个角度来看，在 async 函数中用 try...catch 来包住 await 表达式，可能就是 catch 住这个异常，并且把这个 reject 信息传到 catch 里面。

这里就不举例子了。

为什么要使用 async/await ？