# 使用Promise告别回调函数|浏览器篇

> 本文深入讲解了JavaScript中Promise的诞生背景、解决的异步回调问题及其在前端开发中的重要性，帮助开发者理解如何用Promise优化异步编程，提升代码可读性和维护性。

- 原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part4/19-%E4%BD%BF%E7%94%A8Promise%E5%91%8A%E5%88%AB%E5%9B%9E%E8%B0%83%E5%87%BD%E6%95%B0
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.08
- 可见范围：免费部分

---

## 使用Promise告别回调函数

- `Promise` 解决的是「异步代码怎么写」，不是「异步任务怎么变快」
- 把一个还没出结果的异步操作包成对象，结果只有两条路：成功 `resolve` / 失败 `reject`
- 有依赖的步骤用 `.then` 串起来，不用一层套一层
- 错误沿链往后传，链尾一个 `.catch` 兜住
- 回调还是走事件循环（微任务），写法变了，异步本质没变

**`Promise` 说白了就是把「回调地狱」拉直的工具，它改的是代码组织方式，不改任务本身的耗时。** 以前异步结果只能通过回调拿，步骤一多就层层嵌套、错误处理散在每一层。`Promise` 把「将来才有的结果」包成一个对象，可以先拿着它、晚点再用 `.then` 挂处理函数，几个有依赖的请求能写成一条链，失败也会顺着链跑到最后的 `.catch`。面试里我会特意补一句：接口 `800ms` 换成 `Promise` 还是 `800ms`，它也不会让代码变同步，回调照样排在微任务里执行。

在上一篇文章中我们聊到了微任务是如何工作的，并介绍了 MutationObserver 是如何利用微任务来权衡性能和效率的。今天我们就接着来聊聊微任务的另外一个应用Promise，DOM/BOM API 中新加入的 API 大多数都是建立在 Promise 上的，而且新的前端框架也使用了大量的 Promise。可以这么说，Promise 已经成为现代前端的“水”和“电”，很是关键，所以深入学习 Promise 势在必行。

不过，Promise 的知识点有那么多，而我们只有一篇文章来介绍，那应该怎么讲解呢？具体讲解思路是怎样的呢？

如果你想要学习一门新技术，最好的方式是先了解这门技术是如何诞生的，以及它所解决的问题是什么。了解了这些后，你才能抓住这门技术的本质。所以本文我们就来重点聊聊 JavaScript 引入 Promise 的动机，以及解决问题的几个核心关键点。

要谈动机，我们一般都是先从问题切入，那么 Promise 到底解决了什么问题呢？在正式开始介绍之前，我想有必要明确下，Promise 解决的是异步编码风格的问题，而不是一些其他的问题，所以接下来我们聊的话题都是围绕编码风格展开的

- **同事说把请求从回调改成 `Promise`，首屏能快 `200ms`，你信吗？**

  不信。网络和服务端耗时一点没变，`Promise` 只是换了个拿结果的方式。真要快得从请求本身下手，比如并发、缓存、减少串行依赖。

- **那 `Promise` 到底解决了回调的哪两个痛点？**

  一是嵌套：有依赖的步骤不用再塞进上一步的回调里，`.then` 返回新的 `Promise` 就能接着串；二是错误处理重复：每一层不用各写一个失败回调，未处理的 `reject` 会一路冒泡到链尾 `.catch`。

- **只有一次请求、一个回调的老代码，要不要统一改成 `Promise`？**

  不急。单层回调本来就清楚，改了收益很小还要回归测试。等这段逻辑要和别的异步步骤组合、或者要接到 `async/await` 里时，再顺手包一层就行。

- **改成 `Promise` 之后日志顺序和预想的不一样，是没生效吗？**

  多半是把它当成同步了。`.then` 的回调永远在当前同步代码跑完之后才执行，比如 `console.log(1); p.then(() => console.log(2)); console.log(3)` 输出是 `1 3 2`。

- **现在都写 `async/await` 了，还有必要搞懂 `Promise` 吗？**

  必须懂。`async` 函数返回的就是 `Promise`，`await` 等的也是 `Promise`，并发要用 `Promise.all`，竞速要用 `Promise.race`。不懂 `Promise`，`await` 的执行顺序和错误传递都讲不清。

## 异步编程的问题：代码逻辑不连续

- 页面主线程只有一条，耗时活（下载、读设备）交给别的线程 / 进程干
- 干完 → 往消息队列塞一个任务 → 事件循环取出来 → 执行你注册的回调
- 这样主线程不被卡住，代价是「发起」和「处理结果」被拆到了两个地方
- 一次 `XMLHttpRequest` 就要挂成功、失败、超时多个回调，配置和业务搅在一起
- 「回调多」本身不是错，问题是业务逻辑被切成碎片，读不出先后顺序

**异步编程最大的麻烦是代码逻辑不连续：任务在这里发起，结果却在另一个回调里处理。** 浏览器页面是单线程的，下载文件这种耗时活会交给网络线程去做，主线程接着处理别的任务，等下载完成再往消息队列里放一个任务，事件循环轮到它时才执行你的回调。好处是页面不会卡死，坏处是一次 `XMLHttpRequest` 要挂 `onerror`、`ontimeout`、`onreadystatechange` 好几个回调，请求配置和业务处理交错在一起，读代码时脑子得来回跳。

```js
const xhr = new XMLHttpRequest()
xhr.ontimeout = e => onReject(e)        // 回调 1
xhr.onerror = e => onReject(e)          // 回调 2
xhr.onreadystatechange = () => {        // 回调 3
  if (xhr.readyState === 4 && xhr.status === 200) onResolve(xhr.response)
}
xhr.open('GET', url, true)              // true = 异步
xhr.timeout = 3000
xhr.send()
console.log('send 之后立刻执行')         // 先于任何回调打印
```

```mermaid
sequenceDiagram
    autonumber
    participant M as 页面主线程
    participant N as 网络线程
    participant Q as 消息队列
    participant L as 事件循环
    M->>N: xhr.send() 发起下载
    M->>M: 继续执行后面的同步代码
    N->>N: 下载数据
    alt 下载成功
        N->>Q: 放入 readystatechange 任务
    else 超时或断网
        N-->>Q: 放入 timeout / error 任务
    end
    L->>Q: 主线程空闲时取下一个任务
    Q-->>L: 返回回调任务
    L->>M: 执行注册的回调
```

首先我们来回顾下 JavaScript 的异步编程模型，你应该已经非常熟悉页面的事件循环系统了，也知道页面中任务都是执行在主线程之上的，相对于页面来说，主线程就是它整个的世界，所以在执行一项耗时的任务时，比如下载网络文件任务、获取摄像头等设备信息任务，这些任务都会放到页面主线程之外的进程或者线程中去执行，这样就避免了耗时任务“霸占”页面主线程的情况。你可以结合下图来看看这个处理过程：

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

上图展示的是一个标准的异步编程模型，页面主线程发起了一个耗时的任务，并将任务交给另外一个进程去处理，这时页面主线程会继续执行消息队列中的任务。等该进程处理完这个任务后，会将该任务添加到渲染进程的消息队列中，并排队等待循环系统的处理。排队结束之后，循环系统会取出消息队列中的任务进行处理，并触发相关的回调操作。

这就是页面编程的一大特点：异步回调。

Web 页面的单线程架构决定了异步回调，而异步回调影响到了我们的编码方式，到底是如何影响的呢？

假设有一个下载的需求，使用 XMLHttpRequest 来实现，具体的实现方式你可以参考下面这段代码：

```js
// 执行状态
function onResolve(response){console.log(response) }
function onReject(error){console.log(error) }

let xhr = new XMLHttpRequest()
xhr.ontimeout = function(e) { onReject(e)}
xhr.onerror = function(e) { onReject(e) }
xhr.onreadystatechange = function () { onResolve(xhr.response) }

// 设置请求类型，请求 URL，是否同步信息
let URL = 'https://time.geekbang.com'
xhr.open('Get', URL, true);

// 设置参数
xhr.timeout = 3000 // 设置 xhr 请求的超时时间
xhr.responseType = "text" // 设置响应返回的数据格式
xhr.setRequestHeader("X_TEST","time.geekbang")

// 发出请求
xhr.send();
```

我们执行上面这段代码，可以正常输出结果的。但是，这短短的一段代码里面竟然出现了五次回调，这么多的回调会导致代码的逻辑不连贯、不线性，非常不符合人的直觉，这就是异步回调影响到我们的编码方式。

那有什么方法可以解决这个问题吗？当然有，我们可以封装这堆凌乱的代码，降低处理异步回调的次数。

- **大文件上传时按钮还能点、页面还能滚，能说明上传已经结束了吗？**

  不能。页面能响应只说明上传没占着主线程，它在网络线程里跑着呢。结束没结束看 `onload` 或进度事件，别看页面卡不卡。

- **为了让代码从上到下顺着读，把 `xhr.open` 第三个参数改成 `false` 行不行？**

  不行。同步 `XHR` 会把主线程卡住，请求期间页面点不动、动画停住，主流浏览器早就在主线程上标记它废弃了。要线性的写法，用 `Promise` 或 `async/await` 包一层。

- **接口日志显示 `100ms` 就返回了，页面上的成功提示却晚了 `2` 秒才出来，查哪里？**

  查主线程。网络早完成了，回调任务排在消息队列里，主线程被别的长任务占着取不出来。`Performance` 面板录一下，找那段 `2` 秒左右的长任务。

- **能不能只留 `onreadystatechange`，把 `onerror` 和 `ontimeout` 删掉省点代码？**

  别删。网络断开和超时走的是另外两个事件，删了之后这些失败要么没人处理，要么在 `readystatechange` 里被当成 `status` 为 `0` 的请求混过去，排查时分不清原因。要省代码就封装一层，对外只暴露成功和失败。

## 封装异步代码，让处理流程变得线性

- 思路：调用方只关心输入（请求信息）和输出（结果），中间的 `XHR` 细节藏起来
- `makeRequest` 负责拼 `request` 对象：`method`、`url`、`headers`、`timeout`、`responseType`
- `XFetch(request, resolve, reject)` 负责建 `XHR`、绑事件，把一堆底层事件收敛成两个出口
- 判成功要写 `readyState === 4 && status === 200`，用 `===` 比较
- 局限：还是回调传参，多个有依赖的请求照样会嵌套

**封装的思路是把「请求配置 + 事件绑定」这些噪音收进一个函数，业务代码只交代请求什么、成功干嘛、失败干嘛。** 我一般会拆成两块：`makeRequest` 生成一个描述请求的对象，`XFetch` 拿着这个对象去建 `XMLHttpRequest`、挂事件，最后只回调 `resolve` 或 `reject`。这样单个请求干净多了，但它还是靠把回调当参数传进去，第二个请求要等第一个结果时，只能写进第一个的 `resolve` 里，嵌套问题没解决，这才引出了 `Promise`。

```js
function XFetch(request, resolve, reject) {
  const xhr = new XMLHttpRequest()
  xhr.ontimeout = reject
  xhr.onerror = reject
  xhr.onreadystatechange = () => {
    if (xhr.readyState !== 4) return              // 只在请求结束时结算
    if (xhr.status === 200) resolve(xhr.response)  // === 比较，别写成 =
    else reject({ code: xhr.status })
  }
  xhr.open(request.method, request.url, true)
  xhr.timeout = request.timeout
  xhr.responseType = request.responseType
  xhr.send(request.body)
}
```

由于我们重点关注的是输入内容（请求信息）和输出内容（回复信息），至于中间的异步请求过程，我们不想在代码里面体现太多，因为这会干扰核心的代码逻辑。整体思路如下图所示：

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

从图中你可以看到，我们将 XMLHttpRequest 请求过程的代码封装起来了，重点关注输入数据和输出结果。

那我们就按照这个思路来改造代码。首先，我们把输入的 HTTP 请求信息全部保存到一个 request 的结构中，包括请求地址、请求头、请求方式、引用地址、同步请求还是异步请求、安全设置等信息。request 结构如下所示：

```js
//makeRequest 用来构造 request 对象
function makeRequest(request_url) {
    let request = {
        method: 'Get',
        url: request_url,
        headers: '',
        body: '',
        credentials: false,
        sync: true,
        responseType: 'text',
        referrer: ''
    }
    return request
}
```

然后就可以封装请求过程了，这里我们将所有的请求细节封装进 XFetch 函数，XFetch 代码如下所示：

```js
//[in] request，请求信息，请求头，延时值，返回类型等
//[out] resolve, 执行成功，回调该函数
//[out] reject  执行失败，回调该函数
function XFetch(request, resolve, reject) {
    let xhr = new XMLHttpRequest()
    xhr.ontimeout = function (e) { reject(e) }
    xhr.onerror = function (e) { reject(e) }
    xhr.onreadystatechange = function () {
        if (xhr.status = 200)
            resolve(xhr.response)
    }
    xhr.open(request.method, URL, request.sync);
    xhr.timeout = request.timeout;
    xhr.responseType = request.responseType;
    // 补充其他请求信息
    //...
    xhr.send();
}
```

这个 XFetch 函数需要一个 request 作为输入，然后还需要两个回调函数 resolve 和 reject，当请求成功时回调 resolve 函数，当请求出现问题时回调 reject 函数。

有了这些后，我们就可以来实现业务代码了，具体的实现方式如下所示：

```js
XFetch(makeRequest('https://time.geekbang.org'),
  function resolve(data) {
      console.log(data)
  }, function reject(e) {
      console.log(e)
  })
```

- **线上所有请求都进了成功分支，连 `500` 都算成功，代码里会是什么问题？**

  大概率是 `if (xhr.status = 200)` 这种写法，单等号是赋值，表达式恒为真。改成 `===`，再加上 `readyState === 4` 的判断，不然请求中途的状态变化也会触发 `resolve`。

- **封装完了，业务里还在自己挂 `onerror`、`ontimeout`，这算封装到位吗？**

  不算。封装的意义就是让调用方只碰 `request`、`resolve`、`reject` 三样东西，底层事件还漏在外面，等于只是把代码挪了个位置。

- **登录态改成每次请求动态生成 `token` 头，要绕过 `XFetch` 直接写 `xhr` 吗？**

  不用，给 `request` 加个 `headers` 字段，`XFetch` 里统一 `setRequestHeader`。更省事的是在封装层统一注入 `token`，业务连这个字段都不用传，现在 `axios` 拦截器干的就是这事。

- **封装后还有什么问题没解决？**

  回调还是作为参数传进去的。比如先拿分类、再拿专栏、再拿详情，第二个 `XFetch` 只能写进第一个的 `resolve` 里，三层就开始缩进爆炸，每层还各有一个 `reject`。

- **为什么 `XFetch` 里要判断 `readyState === 4`？**

  `onreadystatechange` 在请求过程中会触发好几次，`readyState` 从 `1` 走到 `4`，只有 `4` 才表示请求结束、`status` 和响应体可信。不判断的话同一个请求可能调好几次 `resolve`。

## 新的问题：回调地狱

- 回调地狱 = 有依赖的异步任务一层套一层 + 每层都要写成功 / 失败两条路
- 乱的根因两个：嵌套调用、错误处理重复
- 对应解法：消灭嵌套（链式）、合并错误处理（统一 `catch`）
- 没依赖的请求别硬写成嵌套，那是人为制造串行
- 拆成命名函数只是好看点，嵌套关系和重复的错误分支都还在

**回调地狱就是后一个请求依赖前一个结果，只能写进前一个的成功回调里，三四层下来代码横着长，每层还挂一个失败回调。** 它乱在两个地方：一是嵌套，业务逻辑全埋在回调里面；二是每个任务都有成功和失败两种结果，每层都得各判断一次。所以治理也就两条，把嵌套拉平成一条链，把错误集中到一个地方处理，`Promise` 干的正是这两件事。

```js
// 三层依赖：分类 → 专栏 → 详情
XFetch(req1, res1 => {
  XFetch(req2, res2 => {
    XFetch(req3, res3 => render(res3), e => console.log(e))
  }, e => console.log(e))
}, e => console.log(e))
```

上面的示例代码已经比较符合人的线性思维了，在一些简单的场景下运行效果也是非常好的，不过一旦接触到稍微复杂点的项目时，你就会发现，如果嵌套了太多的回调函数就很容易使得自己陷入了回调地狱，不能自拔。你可以参考下面这段让人凌乱的代码：

```js
XFetch(makeRequest('https://time.geekbang.org/?category'),
  function resolve(response) {
      console.log(response)
      XFetch(makeRequest('https://time.geekbang.org/column'),
          function resolve(response) {
              console.log(response)
              XFetch(makeRequest('https://time.geekbang.org')
                  function resolve(response) {
                      console.log(response)
                  }, function reject(e) {
                      console.log(e)
                  })
          }, function reject(e) {
              console.log(e)
          })
  }, function reject(e) {
      console.log(e)
  })
```

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part4/19-%E4%BD%BF%E7%94%A8Promise%E5%91%8A%E5%88%AB%E5%9B%9E%E8%B0%83%E5%87%BD%E6%95%B0
