# async await使用同步方式写异步代码|浏览器篇

> 本文详细介绍了如何在浏览器中使用async/await以同步方式编写异步代码，分析了Promise、Generator、协程等底层原理，并对比了传统Promise链式写法与async/await的优势，帮助前端开发者更清晰地理解和应用现代JavaScript异步编程。

- 原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part4/20-async%20await%E4%BD%BF%E7%94%A8%E5%90%8C%E6%AD%A5%E6%96%B9%E5%BC%8F%E5%86%99%E5%BC%82%E6%AD%A5%E4%BB%A3%E7%A0%81
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.08
- 可见范围：免费部分

---

## async await使用同步方式写异步代码

- `async/await` = 用同步的写法写异步，`.then` 链拉成一行行赋值语句
- `ES2017` 正式进标准，底层是 `Promise` + 生成器式的暂停 / 恢复（协程）
- `await` 只暂停当前 `async` 函数，主线程照样处理别的任务，不会卡页面
- 错误用 `try...catch` 接，和同步代码一个写法
- 坑：没依赖的请求连续 `await` 会被写成串行

**`async/await` 让你用写同步代码的方式写异步逻辑，看起来像一行行顺序执行，底层还是 `Promise` 加函数的暂停和恢复。** `.then` 链虽然拉平了嵌套，但满屏 `then` 读起来还是绕；`await` 之后，拿结果就是普通的赋值，错误也能直接 `try...catch`。要讲清楚的是它不阻塞：`await` 只是把当前这个函数挂起，主线程该干嘛干嘛，结果回来了再从挂起的地方接着跑。

```js
async function load() {
  try {
    const user = await fetch('/api/user').then(r => r.json())
    const orders = await fetch(`/api/orders?uid=${user.id}`) // 依赖 user，必须等
    console.log(await orders.json())
  } catch (err) {
    console.error(err) // 任意一步失败都到这里
  }
}
```

在上篇文章中，我们介绍了怎么使用 Promise 来实现回调操作，使用 Promise 能很好地解决回调地狱的问题，但是这种方式充满了 Promise 的 then() 方法，如果处理流程比较复杂的话，那么整段代码将充斥着 then，语义化不明显，代码不能很好地表示执行流程。

比如下面这样一个实际的使用场景：我先请求极客邦的内容，等返回信息之后，我再请求极客邦的另外一个资源。下面代码展示的是使用 fetch 来实现这样的需求，fetch 被定义在 window 对象中，可以用它来发起对远程资源的请求，该方法返回的是一个 Promise 对象，这和我们上篇文章中讲的 XFetch 很像，只不过 fetch 是浏览器原生支持的，并有没利用 XMLHttpRequest 来封装。

```js
fetch('https://www.geekbang.org')
  .then((response) => {
      console.log(response)
      return fetch('https://www.geekbang.org/test')
  }).then((response) => {
      console.log(response)
  }).catch((error) => {
      console.log(error)
  })
```

从这段 Promise 代码可以看出来，使用 promise.then 也是相当复杂，虽然整个请求流程已经线性化了，但是代码里面包含了大量的 then 函数，使得代码依然不是太容易阅读。基于这个原因，ES7 引入了 async/await，这是 JavaScript 异步编程的一个重大改进，提供了在不阻塞主线程的情况下使用同步代码实现异步访问资源的能力，并且使得代码逻辑更加清晰。你可以参考下面这段代码：

```js
async function foo(){
  try{
    let response1 = await fetch('https://www.geekbang.org')
    console.log('response1')
    console.log(response1)
    let response2 = await fetch('https://www.geekbang.org/test')
    console.log('response2')
    console.log(response2)
  }catch(err) {
       console.error(err)
  }
}
foo()
```

通过上面代码，你会发现整个异步处理的逻辑都是使用同步代码的方式来实现的，而且还支持 try catch 来捕获异常，这就是完全在写同步代码，所以是非常符合人的线性思维的。但是很多人都习惯了异步回调的编程思维，对于这种采用同步代码实现异步逻辑的方式，还需要一个转换的过程，因为这中间隐藏了一些容易让人迷惑的细节。

那么本篇文章我们继续深入，看看 JavaScript 引擎是如何实现 async/await 的。如果上来直接介绍 async/await 的使用方式的话，那么你可能会有点懵，所以我们就从其最底层的技术点一步步往上讲解，从而带你彻底弄清楚 async 和 await 到底是怎么工作的。

本文我们首先介绍生成器（Generator）是如何工作的，接着讲解 Generator 的底层实现机制——协程（Coroutine）；又因为 async/await 使用了 Generator 和 Promise 两种技术，所以紧接着我们就通过 Generator 和 Promise 来分析 async/await 到底是如何以同步的方式来编写异步代码的。

- **按钮还能点，有人说 `await fetch()` 会卡住主线程，你怎么看？**

  不会卡。`await` 挂起的是当前 `async` 函数，主线程立刻回去处理别的任务。页面真卡了，要去找主线程上的长计算，不是网络等待造成的。

- **两个报表接口互不依赖，连写两个 `await`，有什么问题？**

  第二个请求要等第一个回来才发，总耗时变成两者之和。先同时发起再等：`const [a, b] = await Promise.all([getA(), getB()])`。

- **第一个 `await` 后面的请求偶尔没发出去，先看什么？**

  看第一个 `await` 是不是 `reject` 了。一抛错就直接跳进 `catch`，后面的代码根本不会执行。如果业务允许它失败后继续，就单独给这一步加 `try...catch` 或者 `.catch(() => 默认值)`。

- **`fetch` 是不是 `XMLHttpRequest` 的封装？**

  不是，`fetch` 是浏览器原生实现的另一套 `API`，直接返回 `Promise`。还有个容易踩的坑：`fetch` 遇到 `404`、`500` 不会 `reject`，只有网络失败才 `reject`，要自己判断 `res.ok`。

- **`.then` 写法和 `await` 写法性能上有差别吗？**

  可以忽略。两者都基于 `Promise`，选哪个看可读性；真正影响性能的是有没有把能并发的请求写成了串行。

## 生成器 VS 协程

- 生成器 `function*`：调用只返回生成器对象，函数体一行都不跑
- `next()` 开始 / 恢复执行，遇到 `yield` 暂停并把值交出去，`return` 就结束
- 协程 = 跑在线程上、能暂停能恢复的函数；一个线程上同一时刻只有一个协程在跑
- 切换由程序自己控制（用户态），不是操作系统调度，开销比线程小得多，也不是并发
- 生成器 `yield` 出 `Promise`，再配一个执行器（比如 `co`）自动调 `next()`，就是 `async/await` 的前身

**生成器是 `JS` 里能暂停、能恢复的函数，它背后的模型就是协程。** 调用 `genDemo()` 只是创建了一个协程，函数体一行都不执行；调 `next()` 它才开始跑，遇到 `yield` 就停下来，把值交给外面，再调 `next()` 从停下的地方继续。外面的代码和生成器在同一个线程上轮流拿控制权，切换时引擎负责保存和恢复各自的调用栈，所以是交替执行，不是并发。

```js
function* gen() {
  console.log('A')
  const x = yield 1      // 暂停，把 1 交出去
  console.log('B', x)
  return 3
}
const g = gen()          // 什么都不打印
console.log(g.next())    // A，然后 { value: 1, done: false }
console.log(g.next(2))   // B 2，然后 { value: 3, done: true }
```

我们先来看看什么是生成器函数？

生成器函数是一个带星号函数，而且是可以暂停执行和恢复执行的。我们可以看下面这段代码：

```js
function* genDemo() {
    console.log(" 开始执行第一段 ")
    yield 'generator 2'

    console.log(" 开始执行第二段 ")
    yield 'generator 2'

    console.log(" 开始执行第三段 ")
    yield 'generator 2'

    console.log(" 执行结束 ")
    return 'generator 2'
}

console.log('main 0')
let gen = genDemo()
console.log(gen.next().value)
console.log('main 1')
console.log(gen.next().value)
console.log('main 2')
console.log(gen.next().value)
console.log('main 3')
console.log(gen.next().value)
console.log('main 4')
```

执行上面这段代码，观察输出结果，你会发现函数 genDemo 并不是一次执行完的，全局代码和 genDemo 函数交替执行。其实这就是生成器函数的特性，可以暂停执行，也可以恢复执行。下面我们就来看看生成器函数的具体使用方式：

- 在生成器函数内部执行一段代码，如果遇到 yield 关键字，那么 JavaScript 引擎将返回关键字后面的内容给外部，并暂停该函数的执行。
- 外部函数可以通过 next 方法恢复函数的执行

关于函数的暂停和恢复，相信你一定很好奇这其中的原理，那么接下来我们就来简单介绍下 JavaScript 引擎 V8 是如何实现一个函数的暂停和恢复的，这也会有助于你理解后面要介绍的 async/await。

要搞懂函数为何能暂停和恢复，那你首先要了解协程的概念。协程是一种比线程更加轻量级的存在。你可以把协程看成是跑在线程上的任务，一个线程上可以存在多个协程，但是在线程上同时只能执行一个协程，比如当前执行的是 A 协程，要启动 B 协程，那么 A 协程就需要将主线程的控制权交给 B 协程，这就体现在 A 协程暂停执行，B 协程恢复执行；同样，也可以从 B 协程中启动 A 协程。通常，如果从 A 协程启动 B 协程，我们就把 A 协程称为 B 协程的父协程。

正如一个进程可以拥有多个线程一样，一个线程也可以拥有多个协程。最重要的是，协程不是被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行）。这样带来的好处就是性能得到了很大的提升，不会像线程切换那样消耗资源。

为了让你更好地理解协程是怎么执行的，我结合上面那段代码的执行过程，画出了下面的“协程执行流程图”，你可以对照着代码来分析：

![](https://s.poetries.top/gitee/2019/11/46.png)

**从图中可以看出来协程的四点规则：**

- 通过调用生成器函数 genDemo 来创建一个协程 gen，创建之后，gen 协程并没有立即执行。
- 要让 gen 协程执行，需要通过调用 gen.next。
- 当协程正在执行的时候，可以通过 yield 关键字来暂停 gen 协程的执行，并返回主要信息给父协程。
- 如果协程在执行期间，遇到了 return 关键字，那么 JavaScript 引擎会结束当前协程，并将 return 后面的内容返回给父协程。

不过，对于上面这段代码，你可能又有这样疑问：父协程有自己的调用栈，gen 协程时也有自己的调用栈，当 gen 协程通过 yield 把控制权交给父协程时，V8 是如何切换到父协程的调用栈？当父协程通过 gen.next 恢复 gen 协程时，又是如何切换 gen 协程的调用栈？

要搞清楚上面的问题，你需要关注以下两点内容。

第一点：gen 协程和父协程是在主线程上交互执行的，并不是并发执行的，它们之前的切换是通过 yield 和 gen.next 来配合完成的。

第二点：当在 gen 协程中调用了 yield 方法时，JavaScript 引擎会保存 gen 协程当前的调用栈信息，并恢复父协程的调用栈信息。同样，当在父协程中执行 gen.next 时，JavaScript 引擎会保存父协程的调用栈信息，并恢复 gen 协程的调用栈信息。

为了直观理解父协程和 gen 协程是如何切换调用栈的，你可以参考下图

![](https://s.poetries.top/gitee/2019/11/47.png)

到这里相信你已经弄清楚了协程是怎么工作的，其实在 JavaScript 中，生成器就是协程的一种实现方式，这样相信你也就理解什么是生成器了。那么接下来，我们使用生成器和 Promise 来改造开头的那段 Promise 代码。改造后的代码如下所示：

```js
//foo 函数
function* foo() {
    let response1 = yield fetch('https://www.geekbang.org')
    console.log('response1')
    console.log(response1)
    let response2 = yield fetch('https://www.geekbang.org/test')
    console.log('response2')
    console.log(response2)
}

// 执行 foo 函数的代码
let gen = foo()
function getGenPromise(gen) {
    return gen.next().value
}
getGenPromise(gen).then((response) => {
    console.log('response1')
    console.log(response)
    return getGenPromise(gen)
}).then((response) => {
    console.log('response2')
    console.log(response)
})
```

从图中可以看到，foo 函数是一个生成器函数，在 foo 函数里面实现了用同步代码形式来实现异步操作；但是在 foo 函数外部，我们还需要写一段执行 foo 函数的代码，如上述代码的后半部分所示，那下面我们就来分析下这段代码是如何工作的。

- 首先执行的是let gen = foo()，创建了 gen 协程。
- 然后在父协程中通过执行 gen.next 把主线程的控制权交给 gen 协程。
- gen 协程获取到主线程的控制权后，就调用 fetch 函数创建了一个 Promise 对象 response1，然后通过 yield 暂停 gen 协程的执行，并将 response1 返回给父协程。
- 父协程恢复执行后，调用 response1.then 方法等待请求结果。
- 等通过 fetch 发起的请求完成之后，会调用 then 中的回调函数，then 中的回调函数拿到结果之后，通过调用 gen.next 放弃主线程的控制权，将控制权交 gen 协程继续执行下个请求。

以上就是协程和 Promise 相互配合执行的一个大致流程。不过通常，我们把执行生成器的代码封装成一个函数，并把这个执行生成器代码的函数称为执行器（可参考著名的 co 框架），如下面这种方式：

```js
function* foo() {
    let response1 = yield fetch('https://www.geekbang.org')
    console.log('response1')
    console.log(response1)
    let response2 = yield fetch('https://www.geekbang.org/test')
    console.log('response2')
    console.log(response2)
}
co(foo());
```

通过使用生成器配合执行器，就能实现使用同步的方式写出异步代码了，这样也大大加强了代码的可读性。

- **调了 `genDemo()`，里面第一行日志没打出来，是函数没执行成功吗？**

  是根本没开始执行。生成器函数调用只返回一个生成器对象，第一次 `g.next()` 才会跑到第一个 `yield`。

- **日志里外层和生成器交替输出，是不是两个线程在并发，要不要加锁？**

  不用。它们在同一个线程上，同一时刻只有一个在跑，控制权靠 `yield` 和 `next()` 来回交接。`JS` 主线程里不存在线程级竞态，要注意的只是异步回调交错带来的状态问题。

- **生成器里两个 `yield fetch()`，第一个请求回来了，第二个却一直没发，为什么？**

  `yield` 只负责暂停，不会自己等 `Promise` 完成后恢复。得有人在 `.then` 里再调一次 `g.next(result)`，执行器没写或者漏了失败分支，它就永远停在第一个 `yield`。

- **`co` 这类执行器到底帮你干了什么？**

  循环做一件事：拿到 `yield` 出来的 `Promise`，等它成功就把结果通过 `next(value)` 传回去，失败就 `g.throw(err)`，直到 `done` 为 `true`。`async/await` 可以理解成把「生成器 + 执行器」做进了语言里。

- **协程切换为什么比线程切换便宜？**

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part4/20-async%20await%E4%BD%BF%E7%94%A8%E5%90%8C%E6%AD%A5%E6%96%B9%E5%BC%8F%E5%86%99%E5%BC%82%E6%AD%A5%E4%BB%A3%E7%A0%81
