JavaScript-04-异步编程
这篇讲什么
JavaScript 是单线程的,却要同时处理网络请求、定时器、用户点击——靠的就是事件循环(Event Loop)。
本篇从「为什么需要异步」出发,完整拆解事件循环的执行顺序,再依次讲透回调、
Promise、async/await三代异步写法,最后给出并发控制、取消请求与反模式清单。读完你应该能准确预测任意一段异步代码的输出顺序。
一、是什么
异步编程(Asynchronous Programming) 指的是:发起一个耗时操作后不等待它完成,先继续执行后面的代码;
等操作完成时,再通过回调、Promise 或 await 的恢复机制回来处理结果。
与之相对的是同步(Synchronous)代码:一行执行完才走下一行,耗时操作会把整条执行线索「卡住」。
用一个生活中的比喻:
| 模型 | 类比 | 后果 |
|---|---|---|
| 同步阻塞 | 点外卖后站在店门口等,直到做好才回家 | 这一小时什么都做不了 |
| 异步回调 | 点完外卖留下电话,回家干别的事 | 电话响了再去取,时间被复用 |
JavaScript 的异步不是靠多线程,而是靠事件循环在单线程上把「等待时间」复用起来。
这是它与 C# 的 Task、Python 的 asyncio 在实现层面最大的差别:
后两者语言本身支持多线程/协程调度,而 JS 的宿主环境(浏览器、Node.js)只有一条执行 JS 的主线程。
二、为什么这样设计
2.1 单线程:历史的选择,也是必然
JS 诞生于浏览器,最初的职责是操作 DOM。如果允许两条线程同时改同一个 DOM 节点,
就必须引入锁(Lock)来保证一致性——而这会让一门给网页写脚本的语言变得极其笨重。
// 假设 JS 是多线程的,下面这段代码根本无法定义「正确答案」
// 线程 A: title.textContent = '你好';
// 线程 B: title.remove();
// 此刻 title 到底是「有文字的新节点」还是「已被删除」?
于是设计者做了一个取舍:只有一条线程可以执行 JS 代码,耗时操作交给宿主环境(浏览器/Node.js)去后台做,
做完之后把回调「排队」回主线程。这条主线就是事件循环。
2.2 阻塞(Blocking)的代价
「单线程」意味着任何一段同步代码都会独占主线程。耗时计算、同步 I/O、甚至一个写错的死循环,
都会让页面失去响应。下面这段代码可以在 Chrome DevTools 控制台里直接粘贴运行:
// 运行环境:Chrome / Edge DevTools 控制台(或任何浏览器控制台)
console.time('sync');
// Atomics.wait 是少数能在浏览器主线程里制造「真同步等待」的方式
try {
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2000); // 阻塞 2 秒
} catch (e) {
// 部分浏览器主线程禁止 Atomics.wait,退化说明即可
const end = Date.now() + 2000;
while (Date.now() < end) { /* 忙等待同样会卡住主线程 */ }
}
console.timeEnd('sync'); // sync: 2000ms 左右
console.log('主线程在这 2 秒里无法响应任何点击、无法渲染任何界面');
核心结论
阻塞主线程 = 页面冻结。时间复杂度的直觉在这里要换成「墙钟时间(Wall-clock Time)」的直觉:
一个 的同步循环放大到 时,用户看到的就是「页面未响应」。
异步的意义不是让计算变快,而是不占用主线程。
2.3 为什么不用「多开线程」解决
浏览器确实提供了 Web Worker 与 Node.js 提供了 Worker Threads,但它们:
- 运行在独立的执行环境,没有 DOM 访问权(Worker 里改不了页面);
- 与主线程只能通过消息(
postMessage)通信,数据需要结构化克隆(Structured Clone),有序列化开销; - 每个 Worker 有自己的事件循环,调试与状态同步成本高。
所以日常业务代码的异步,仍然是基于事件循环的协作式调度,而不是把工作拆到多个线程。
三、核心内容
3.1 事件循环的完整机制
先建立四个角色的心智模型:
| 角色 | 存放什么 | 谁往里放 |
|---|---|---|
| 调用栈(Call Stack) | 当前正在执行的函数帧 | JS 引擎 |
| 宏任务队列(Macrotask Queue) | 整段 script、setTimeout/setInterval 回调、I/O 回调、UI 事件回调 | 宿主环境 |
| 微任务队列(Microtask Queue) | Promise 的 then/catch/finally 回调、queueMicrotask 回调、await 恢复 | JS 引擎自身 |
| 渲染步骤(Rendering) | 样式计算、布局、绘制 | 浏览器,在两次任务之间择机执行 |
一次循环的算法(简化版,完整规范见 HTML Standard 的 event loop processing model):
1. 从宏任务队列中取出「最早入队」的一个任务,执行它,直到调用栈清空
2. 清空微任务队列:只要队列非空,就取出最早的一个执行
—— 注意:微任务执行过程中新产生的微任务,也在本轮被清空
3. 如果浏览器判断需要渲染,就执行渲染(样式 → 布局 → 绘制)
4. 若宏任务队列为空,休眠等待新任务到来;否则回到第 1 步
把这段流程画成时序:
flowchart LR
A["取一个宏任务"] --> B["执行到调用栈清空"]
B --> C{"微任务队列非空?"}
C -- 是 --> D["执行最早的微任务"] --> C
C -- 否 --> E["渲染(需要时)"]
E --> A
两条必须记住的规则:
- 每个宏任务执行完后,会立刻清空整个微任务队列,然后才可能渲染、才可能执行下一个宏任务。
- 微任务之间不会插入渲染,也不会插入 UI 事件。所以微任务里写死循环 = 页面直接卡死,连「未响应」提示都可能出不来。
用一段代码验证执行顺序
// 运行环境:任意浏览器的 DevTools 控制台
console.log('script start'); // ① 同步
setTimeout(() => console.log('setTimeout'), 0); // 宏任务,入队
Promise.resolve()
.then(() => console.log('promise 1')) // 微任务
.then(() => console.log('promise 2')); // 微任务(由上一个 then 产生)
queueMicrotask(() => console.log('queueMicrotask')); // 微任务
console.log('script end'); // ② 同步
// 输出顺序:
// script start
// script end
// promise 1
// queueMicrotask
// promise 2
// setTimeout
解释:同步代码 ①② 先跑完;随后清空微任务队列。promise 1 与 queueMicrotask 在同一个宏任务里注册,
按注册顺序执行;promise 2 是在 promise 1 的 then 回调执行时才被注册进微任务队列的,
所以排在 queueMicrotask 后面。setTimeout 的回调要等整个微任务队列清空后的下一个宏任务。
渲染发生在什么时候
浏览器不会「定时」渲染,而是按屏幕刷新率(通常是 60Hz → 约 16.7ms 一次)判断是否有渲染时机(Rendering Opportunity)。
渲染插在微任务清空之后、下一个宏任务之前。因此:
// 运行环境:浏览器页面中(写在 <script> 里,或控制台但需先有 #box)
const box = document.createElement('div');
box.id = 'box';
document.body.append(box);
box.style.width = '100px';
Promise.resolve().then(() => {
// 微任务里读到的仍是「已更新但尚未绘制」的值 —— 会触发强制同步布局
console.log(getComputedStyle(box).width); // "100px"
box.style.width = '200px';
});
// 用户最终只会看到 200px:两次修改发生在同一次渲染之前,第一次被「合并」掉了
这解释了为什么「改三次样式」不会闪三下——渲染是批量的,而强制读取布局(offsetWidth、getComputedStyle)会打断批量,
这也是 前端-04-浏览器与HTTP 里「重排(Reflow)」话题的根源。
setTimeout 的最小延迟:为什么 setTimeout(fn, 0) 不立即执行
三个原因叠加:
| 原因 | 说明 |
|---|---|
| 它本来就是宏任务 | 即使延迟为 0,回调也必须排队等当前宏任务 + 所有微任务全部结束 |
| 规范规定的最小延迟 | HTML 规范要求:当嵌套层级(Nesting Level)大于 5 时,最小延迟被钳制为 4ms(见 MDN setTimeout) |
| 浏览器内部节流 | 后台标签页、省电模式下延迟会被进一步拉大(可能变成 1000ms 级别) |
// 运行环境:浏览器 DevTools 控制台
let last = Date.now();
let depth = 0;
function tick() {
const now = Date.now();
console.log(`第 ${depth} 层嵌套,间隔 ${now - last}ms`);
last = now;
if (++depth <= 8) setTimeout(tick, 0);
}
last = Date.now();
tick();
// 前几次约 0~1ms,从第 6 层起稳定在 4ms 左右 —— 这就是「嵌套 4ms 钳制」
这带来的实际影响:用 setTimeout(fn, 0) 把大任务切片执行时,
调度要放在任务开头,否则每次都要白白等 4ms 以上(zh.javascript.info 的事件循环章节专门讨论了这个优化)。
想「尽快、但在当前任务之后」执行,用微任务
queueMicrotask(fn)或Promise.resolve().then(fn)会在当前宏任务结束后、渲染之前执行,没有 4ms 钳制,也不会有定时器精度问题。代价是它会阻塞渲染,不能用来做长耗时任务。
3.2 浏览器与 Node.js 事件循环的差异
Node.js 的 libuv 把事件循环拆成了明确的阶段(Phases),这是与浏览器最大的不同。
flowchart TD
T["timers 阶段<br/>setTimeout / setInterval 到期回调"] --> P["pending callbacks<br/>上一轮延迟的 I/O 回调"]
P --> PO["poll 阶段<br/>等待并执行 I/O 回调(如 fs、net)"]
PO --> C["check 阶段<br/>setImmediate 回调"]
C --> CL["close callbacks<br/>socket.on('close') 等"]
CL --> T
N["process.nextTick 队列<br/>每个阶段切换时先清空它,再清空微任务"] -.-> T
| 对比项 | 浏览器 | Node.js |
|---|---|---|
| 队列划分 | 宏任务队列 + 微任务队列(较简单) | 六个阶段,每个阶段有各自的回调队列 |
| 微任务队列 | Promise 回调、queueMicrotask | 同上,且每个阶段之间都会清空微任务队列 |
| 专属高优先级队列 | 无 | process.nextTick 队列:在回调内部注册时优先于 Promise 回调 |
| 定时器与 I/O 的相对顺序 | 由入队顺序决定,较直观 | 受 poll 阶段耗时影响,setTimeout(fn,0) 与 setImmediate 顺序可能不确定 |
| 渲染 | 有(渲染时机) | 无渲染概念 |
| 事件循环结束条件 | 页面关闭 | 没有待处理的任务/句柄时进程退出 |
// 运行环境:Node.js 20 LTS 及以上,`node nexttick-demo.mjs`
// 关键:把两者注册在「同一个定时器回调内部」,才能看出 nextTick 的优先级
setTimeout(() => {
Promise.resolve().then(() => console.log('1 promise (先注册)'));
process.nextTick(() => console.log('2 nextTick (后注册,却先执行)'));
}, 0);
setImmediate(() => console.log('3 setImmediate (check 阶段)'));
console.log('0 同步代码');
// 输出顺序:
// 0 同步代码
// 2 nextTick (后注册,却先执行)
// 1 promise (先注册)
// 3 setImmediate (check 阶段)
顶层注册时顺序会反过来,别被绕晕
实测(Node.js 24)结果:
| 注册位置 | 观察到的顺序 |
|---|---|
| 模块顶层 | 顶层代码被当作一个「微任务检查点」,
nextTick队列与 Promise 微任务按注册顺序执行 ||
setTimeout/ I/O 回调内部 | 无论注册顺序,nextTick队列都先于 Promise 微任务清空 |所以「
nextTick优先于 Promise」这条经验法则只在回调内部成立。记住结论即可:回调内部要「插队」,用
process.nextTick;否则用queueMicrotask。
process.nextTick是把双刃剑它的命名有误导性——它不是「下一个 tick 执行」,而是「当前操作结束后立即执行,且优先于所有微任务」。
如果在
nextTick回调里递归调用nextTick,事件循环会被永久饿死(Starvation),I/O 与定时器永远得不到执行。Node.js 官方文档现在建议:能用
queueMicrotask()就不要用process.nextTick()(见 Node.jsprocess文档的 "When to use
queueMicrotask()vs.process.nextTick()")。nextTick目前主要用于兼容历史 API 的内部实现。
3.3 第一代写法:回调函数(Callback)
回调函数(Callback Function):把「稍后要执行的逻辑」作为参数传给异步 API。
// 运行环境:浏览器 DevTools 控制台(XMLHttpRequest 浏览器、Node 18+ 都支持)
const xhr = new XMLHttpRequest();
xhr.open('GET', 'https://example.com/api/user/1');
xhr.onload = () => console.log(xhr.responseText);
xhr.onerror = () => console.error('请求失败');
xhr.send();
单个回调很清晰。问题出在依赖串联:后一步需要前一步的结果,于是回调层层嵌套。
回调地狱(Callback Hell):三层嵌套读文件
下面这个例子模拟「读取用户配置 → 根据配置读取数据文件 → 再写入日志」的真实需求:
// 运行环境:Node.js 18+,`node callback-hell.mjs`
import { readFile, writeFile } from 'node:fs';
// 需求:读 config.json → 读它指定的 dataFile → 把内容追加进 log.txt
readFile('config.json', 'utf8', (err1, config) => {
if (err1) {
console.error('读取配置失败:', err1);
return; // ← 必须手动 return,否则会继续往下跑
}
readFile(JSON.parse(config).dataFile, 'utf8', (err2, data) => {
if (err2) {
console.error('读取数据失败:', err2);
return; // ← 又一次重复的错误处理
}
writeFile('log.txt', data + '\n', { flag: 'a' }, (err3) => {
if (err3) {
console.error('写日志失败:', err3);
return; // ← 第三次
}
console.log('全部完成');
});
});
});
痛点一:可读性崩塌。 控制流是「向右再向下」的锯齿(俗称 Pyramid of Doom)。
三层还能忍,真实项目里五层很常见,缩进直接吃掉半屏宽度。
痛点二:错误处理无法复用。 每个回调都要重复一遍 if (err),
而且必须记得 return——忘了写就会在出错后继续执行下一步,产生更隐蔽的 bug。
更糟的是,任何一步的 throw 都不会被外层的 try/catch 捕获:
// 运行环境:Node.js 18+
try {
setTimeout(() => {
throw new Error('回调里的错误');
}, 0);
} catch (e) {
// 永远不会执行!异常发生时,try 块早就出栈了
console.error('捕获到:', e.message);
}
// 实际结果:进程因未捕获异常而崩溃(Node)或控制台报 Uncaught Error(浏览器)
原因:try/catch 依赖调用栈,而异步回调执行时调用栈里早已没有引发它的那个 try。
这是「错误处理」维度的根本缺陷,也是 Promise 被发明出来的直接动机。
痛点三:无法组合。 想「三个请求都完成后统一处理」或「只要最快的一个」,
用回调实现需要自己维护计数器与状态标志,极易写错。
3.4 第二代写法:Promise
三态与不可逆性
Promise 是一个状态机,只有三种状态:
| 状态 | 含义 | 能否再变 |
|---|---|---|
pending(待定) | 初始状态,尚未有结果 | 可以变为 fulfilled 或 rejected |
fulfilled(已兑现) | 成功,带一个 value | 不可再变 |
rejected(已拒绝) | 失败,带一个 reason(通常是 Error) | 不可再变 |
一旦落定(settled,即离开 pending),状态与值都被永久冻结,后续的 resolve/reject 调用一律被忽略:
// 运行环境:任意浏览器 DevTools 控制台
const p = new Promise((resolve, reject) => {
resolve('第一次调用生效');
resolve('第二次被忽略');
reject(new Error('这个 reject 也会被忽略'));
});
p.then(v => console.log('fulfilled:', v)); // fulfilled: 第一次调用生效
p.catch(e => console.log('rejected:', e.message)); // 不会执行
一个容易混淆的细节:
resolve一个 Promise 会「跟随」它
resolve(thenable)中的thenable如果是一个 Promise,那么p会等待它,而不是立刻 fulfilled。见下一节的「不能 resolve 自己」。
then / catch / finally 的返回值与链式调用
这是 Promise 最核心的规则:这三个方法永远返回一个「新的」 Promise,
新 Promise 的状态由回调的返回值决定。
| 回调中的行为 | 新 Promise 的结果 |
|---|---|
return value | fulfilled,值为 value |
不写 return(返回 undefined) | fulfilled,值为 undefined |
return Promise | 等待这个 Promise 落定,采用它的状态与值 |
throw err | rejected,reason 为 err |
回调本身不存在(如只写了 .then(onFulfilled) 却发生了拒绝) | 状态与值原样透传给下一个 |
// 运行环境:任意浏览器 DevTools 控制台
Promise.resolve(1)
.then(v => {
console.log('收到', v);
return v + 1; // 返回值 → 下一个 then 收到 2
})
.then(v => {
throw new Error(`在 ${v} 处出错`); // 抛出 → 进入后面的 catch
})
.then(() => console.log('不会执行')) // 被跳过
.catch(e => {
console.log('捕获:', e.message); // 捕获:在 2 处出错
return 'recovered'; // catch 也能「恢复」链条
})
.finally(() => console.log('finally 不接收参数,也不改变结果'))
.then(v => console.log('最终值:', v)); // 最终值: recovered
finally 的三个特性(MDN):不接收任何参数;不改变链条的值或拒绝原因(原样透传);
但如果它抛错或返回一个 rejected 的 Promise,则会覆盖原来的结果。
错误穿透(Error Propagation)
链条上任意一环抛错或返回被拒绝的 Promise,都会跳过后面所有没有 onRejected 的 then,
直到遇到第一个 catch(或带第二个参数的 then)。这就是错误穿透:
// 运行环境:浏览器 DevTools 控制台
const steps = [];
Promise.resolve('a')
.then(v => { steps.push('step1'); return v; })
.then(() => { steps.push('step2'); throw new Error('boom'); })
.then(() => { steps.push('step3(被跳过)'); })
.then(() => { steps.push('step4(被跳过)'); })
.catch(e => { steps.push('catch: ' + e.message); })
.then(() => console.log(steps.join(' → ')));
// step1 → step2 → catch: boom
实践建议:把
.catch放在链尾一个链条只在末尾写一个
catch,就能覆盖前面所有环节的错误——这是回调风格永远做不到的。中间步骤若需要「失败后降级继续」,再单独在那一环加
catch并返回兜底值。
静态方法四件套对比
| 方法 | 何时落定 | 成功结果 | 失败行为 | 典型场景 |
|---|---|---|---|---|
Promise.all | 全部 fulfilled | 结果数组,顺序与输入一致 | 任意一个 rejected 立刻整体 rejected(其余结果被忽略,但不会取消) | 多接口数据必须齐全才能渲染 |
Promise.allSettled | 全部 settled | {status:'fulfilled', value} / {status:'rejected', reason} 数组,从不 rejected | 无(永远 fulfilled) | 批量上传、逐个展示成功/失败 |
Promise.race | 第一个 settled(成功或失败都算) | 第一个落定者的值 | 第一个落定者若是失败,则整体失败 | 超时竞速:race([请求, 超时]) |
Promise.any | 第一个 fulfilled | 第一个成功的值 | 全部失败时以 AggregateError 拒绝,其 errors 属性含所有原因 | 多镜像源取最快可用的一个 |
// 运行环境:Node.js 18+(原生 fetch 需要 Node 18 及以上),`node promise-combos.mjs`
const ok = (v, ms) => new Promise(r => setTimeout(() => r(v), ms));
const bad = (msg, ms) => new Promise((_, rj) => setTimeout(() => rj(new Error(msg)), ms));
// 1) all:一荣俱荣 —— 结果顺序按输入,不按完成时间
console.log(await Promise.all([ok('慢', 100), ok('快', 10)])); // [ '慢', '快' ]
// 2) allSettled:永不失败,适合「逐个展示」
console.log(await Promise.allSettled([ok(1, 10), bad('坏了', 20)]));
// [ { status: 'fulfilled', value: 1 }, { status: 'rejected', reason: Error: 坏了 } ]
// 3) race:第一个落定者说了算 —— 常用作超时
const timeout = (ms) => new Promise((_, rj) => setTimeout(() => rj(new Error('超时')), ms));
try {
await Promise.race([ok('数据', 500), timeout(100)]);
} catch (e) {
console.log('race 失败:', e.message); // race 失败: 超时
}
// 4) any:只认第一个成功者
console.log(await Promise.any([bad('镜像1挂了', 10), ok('镜像2可用', 50)])); // 镜像2可用
// 5) any 全部失败:AggregateError
try {
await Promise.any([bad('a', 10), bad('b', 20)]);
} catch (e) {
console.log(e.constructor.name, e.errors.map(x => x.message)); // AggregateError [ 'a', 'b' ]
}
手写一个简易 Promise:理解原理
自己实现一遍,三件事就彻底清楚了:executor 同步执行、状态机不可逆、then 回调走微任务。
// 运行环境:Node.js 18+ 或浏览器控制台,`node my-promise.mjs`
const PENDING = 'pending', FULFILLED = 'fulfilled', REJECTED = 'rejected';
class MyPromise {
#state = PENDING; // 状态机
#value; // 成功值
#reason; // 失败原因
#onFulfilledCbs = []; // pending 期间注册的成功回调
#onRejectedCbs = []; // pending 期间注册的失败回调
constructor(executor) {
// executor 由 new 时立即同步执行 —— 这就是「Promise 一经创建就已开始」的原因
const resolve = (value) => this.#settle(FULFILLED, value);
const reject = (reason) => this.#settle(REJECTED, reason);
try {
executor(resolve, reject);
} catch (err) {
reject(err); // executor 内部同步抛错 → 变成 rejected
}
}
#settle(state, payload) {
if (this.#state !== PENDING) return; // 不可逆:已落定则忽略后续调用
// resolve(thenable) 要「跟随」它(真实规范里的 Promise Resolution Procedure 会递归处理)
if (state === FULFILLED && payload && typeof payload.then === 'function') {
payload.then(
(v) => this.#settle(FULFILLED, v),
(r) => this.#settle(REJECTED, r),
);
return;
}
this.#state = state;
if (state === FULFILLED) this.#value = payload;
else this.#reason = payload;
// 落定后统一调度已注册的回调
queueMicrotask(() => {
const cbs = state === FULFILLED ? this.#onFulfilledCbs : this.#onRejectedCbs;
cbs.forEach((cb) => cb(payload));
});
}
then(onFulfilled, onRejected) {
// then 必须返回「新的」Promise,链式调用才有意义
return new MyPromise((resolve, reject) => {
const handle = (cb, fallback, payload) => {
if (typeof cb !== 'function') return fallback(payload); // 穿透:非函数则原样传递
try {
resolve(cb(payload)); // 回调返回值决定新 Promise(若为 Promise 会被跟随)
} catch (err) {
reject(err); // 回调抛错 → 新 Promise rejected
}
};
// 关键:用 queueMicrotask 保证回调异步执行,而不是同步立刻执行
queueMicrotask(() => {
if (this.#state === FULFILLED) {
handle(onFulfilled, resolve, this.#value);
} else if (this.#state === REJECTED) {
handle(onRejected, reject, this.#reason);
} else {
// 还没落定:先把回调挂起来,等 settle 时再统一调度
this.#onFulfilledCbs.push((v) =>
handle(onFulfilled, resolve, v));
this.#onRejectedCbs.push((r) =>
handle(onRejected, reject, r));
}
});
});
}
catch(onRejected) {
return this.then(undefined, onRejected); // catch 就是只有失败回调的 then
}
finally(onFinally) {
// 不接收参数、不改变结果;若自身抛错则覆盖结果
return this.then(
(v) => MyPromise.resolve(onFinally()).then(() => v),
(r) => MyPromise.resolve(onFinally()).then(() => { throw r; }),
);
}
static resolve(value) {
return value instanceof MyPromise ? value : new MyPromise((r) => r(value));
}
}
// —— 验证 ——
const order = [];
new MyPromise((resolve) => {
order.push('executor 同步执行');
resolve(1);
}).then((v) => order.push('then 收到 ' + v));
order.push('then 之后的同步代码');
setTimeout(() => console.log(order.join(' → ')), 0);
// executor 同步执行 → then 之后的同步代码 → then 收到 1
真实规范比这复杂
ECMAScript 规范里还有
PromiseResolveThenableJob、NewPromiseResolveThenableJob、以及「thenable 只允许被调用一次」等细节(见 tc39.es/ecma262 的 Control Abstraction Objects 章节)。
上面这份实现足够解释行为,但不含
Promise.all等静态方法,也不处理循环引用(resolve自己)。
不能 resolve 自己
// 运行环境:浏览器控制台
const p = new Promise((resolve) => setTimeout(() => resolve(p), 0));
p.catch(e => console.log(e.constructor.name)); // TypeError: Chaining cycle detected
3.5 第三代写法:async / await
async/await 是基于 Promise 的语法糖,本质没变——只是把「回调注册」写成了看似同步的样子。
语法与返回值包装
// 运行环境:Node.js 18+,`node async-basics.mjs`
async function f1() { return 1; } // 返回值被包装成 Promise
async function f2() { return Promise.resolve(2); } // 返回 Promise 会被「跟随」并解包
async function f3() { throw new Error('boom'); } // 抛错变成 rejected
console.log(f1()); // Promise { 1 }
console.log(await f1()); // 1
console.log(await f2()); // 2(不是 Promise<Promise<2>>)
await f3().catch(e => console.log(e.message)); // boom
关键点:async 函数永远返回 Promise。所以调用方要么 await,要么 .then,不存在「直接拿到值」的可能。
await 之后代码进入微任务
await 会暂停当前函数,把「后续代码」注册为微任务,然后立刻把控制权还给调用者。
用一段代码就能看出这一点:
// 运行环境:浏览器 DevTools 控制台
async function demo() {
console.log('1 async 开始');
await null; // 即使 await 一个非 Promise,也会让出一次微任务
console.log('3 await 之后'); // 这里是微任务
}
demo();
console.log('2 同步代码');
// 1 async 开始 → 2 同步代码 → 3 await 之后
为什么
await null也会让出
await的语义是「把后续代码挂到该值的 Promise 落定之后」。实现上会走
Promise.resolve(value).then(continuation),因此即使值已就绪,continuation 也必须排进微任务队列,而不是同步继续。这与
then的行为完全一致(见 tc39.es/ecma262 中Await抽象操作)。
用 try/catch 捕获异步错误
这是 await 相对回调最大的工程收益:异步错误可以像同步错误一样被 try/catch 捕获。
// 运行环境:Node.js 18+,`node try-catch-await.mjs`
async function fetchUser(id) {
try {
const res = await fetch(`https://example.com/api/users/${id}`);
if (!res.ok) throw new Error(`HTTP ${res.status}`); // fetch 不会因 4xx/5xx 而 reject!
return await res.json();
} catch (err) {
console.error('统一处理:', err.message);
return null; // 降级:让调用方拿到 null 而不是崩溃
}
}
fetch的「假成功」
fetch只在网络层面失败(断网、DNS 失败、被 CORS 拦截)时 reject。服务器返回 500、404 时,Promise 依然是 fulfilled,必须手动检查
res.ok或res.status。这是新手最常踩的坑之一。另外
res.json()也要await——返回的是 Promise。
在循环中使用 await 的串行陷阱
// 运行环境:Node.js 18+,`node loop-await.mjs`
const ids = [1, 2, 3, 4, 5];
const request = (id) => new Promise(r => setTimeout(() => r({ id }), 300)); // 每个耗时 300ms
// ❌ 写法 A:串行 —— 总耗时 ≈ 5 × 300 = 1500ms
let t = Date.now();
const a = [];
for (const id of ids) {
a.push(await request(id)); // 每次都在等上一个完成
}
console.log(`串行耗时 ${Date.now() - t}ms`); // ≈1500ms
// ✅ 写法 B:并行 —— 总耗时 ≈ 300ms
t = Date.now();
const b = await Promise.all(ids.map((id) => request(id))); // 先全部发起,再统一等待
console.log(`并行耗时 ${Date.now() - t}ms`); // ≈300ms
用公式描述:设单个任务耗时 ,并发度为 ,则
什么时候必须串行? 后一步依赖前一步的结果时。例如「创建订单 → 用订单 ID 发起支付」。
但仅仅是「循环遍历」并不构成依赖,要主动检查是不是可以改成 Promise.all。
for await...of 语法本身也是串行的(每轮 await 一次),它适用于异步可迭代对象
(如逐块读取的流),而不是用来「并行遍历数组」:
// 运行环境:Node.js 18+,`node for-await.mjs`
// 逐个读取数组中的异步任务结果(串行)
async function* gen() {
yield await Promise.resolve('A');
yield await Promise.resolve('B');
}
for await (const v of gen()) console.log(v); // A B
// 真实场景:逐块消费可读流,避免把整个文件读进内存
// import { createReadStream } from 'node:fs';
// for await (const chunk of createReadStream('big.log')) { /* 处理 chunk */ }
数组是同步可迭代的,
for await用在数组上也能跑,但每轮都是串行如果目标只是「并行跑完一个数组」,用
Promise.all(ids.map(...)),不要用
for await,否则白白串行化。
并发控制:手写 pLimit
Promise.all 会一次性发起所有请求。1000 个请求同时打出去,轻则把接口打挂,
重则触发浏览器对同域名连接数的限制(HTTP/1.1 下通常 6 个)反而更慢。
这时需要限制并发度。下面是一个可直接使用的最小实现:
// 运行环境:Node.js 18+,`node plimit.mjs`
// 也可直接放进浏览器页面/模块中使用
function pLimit(concurrency) {
if (!Number.isInteger(concurrency) || concurrency < 1) {
throw new RangeError('concurrency 必须是 >= 1 的整数');
}
const queue = []; // 等待执行的任务
let activeCount = 0; // 正在执行的任务数
const next = () => {
activeCount--;
if (queue.length > 0) queue.shift()(); // 有空位就唤醒队首任务
};
const run = async (fn, resolve, reject) => {
activeCount++;
try {
resolve(await fn()); // 用 await 保证同步抛错也被捕获
} catch (err) {
reject(err);
} finally {
next(); // 无论成功失败都要释放名额
}
};
return (fn) =>
new Promise((resolve, reject) => {
// 队列里放的是「启动这个任务」的闭包,而不是任务本身
queue.push(() => run(fn, resolve, reject));
if (activeCount < concurrency) queue.shift()();
});
}
// —— 使用:100 个任务,最多同时跑 5 个 ——
const limit = pLimit(5);
let running = 0, peak = 0;
const task = (n) => limit(async () => {
running++; peak = Math.max(peak, running);
await new Promise(r => setTimeout(r, 50));
running--;
return n * 2;
});
const results = await Promise.all(
Array.from({ length: 100 }, (_, i) => task(i)),
);
console.log('结果条数:', results.length, '峰值并发:', peak); // 100 峰值并发: 5
实现要点:
- 队列存的是闭包,真正的任务要等到有名额时才执行——若直接
queue.push(fn),任务一进来就跑了。 finally里释放名额,否则一个任务失败就会永久占位,队列卡死。limit()返回 Promise,所以外面仍可以用Promise.all统一等待——并发度与「全部完成」两件事被解耦。
AbortController 取消请求
Promise 本身没有取消机制(这是它被长期批评的设计缺陷)。
取消要由发起方提供:fetch 等 Web API 接受一个 signal 参数。
// 运行环境:浏览器页面 / DevTools 控制台(Node.js 18+ 也支持 fetch + AbortController)
const controller = new AbortController();
const { signal } = controller;
// 场景 1:用户点「取消」
document.querySelector('#cancelBtn')?.addEventListener('click', () => controller.abort());
// 场景 2:超时自动取消
const timeoutId = setTimeout(() => controller.abort(new Error('请求超时')), 3000);
try {
const res = await fetch('https://example.com/api/slow', { signal });
console.log(await res.json());
} catch (err) {
if (err.name === 'AbortError') {
console.warn('请求已被取消');
} else {
console.error('其他错误:', err.message);
}
} finally {
clearTimeout(timeoutId); // 成功也要清掉定时器,避免无谓的 abort
}
关于「超时」的现代写法
新版本运行环境提供
AbortSignal.timeout(ms)与AbortSignal.any([...])组合多个信号,用它们比手写
Promise.race超时干净得多。可用性以 MDNAbortSignal页面与目标浏览器版本为准。需要同时兼容旧环境时,
Promise.race([请求, timeout])仍然有效——但它只是放弃等待,请求仍在后台继续,真正的取消只有
signal能做到。
3.6 常见反模式清单
| 反模式 | 问题 | 正确做法 |
|---|---|---|
async 函数里忘记 await | 错误不会被 try/catch 捕获,变成「未处理的拒绝」 | 每个返回 Promise 的调用都 await 或用 .catch 兜底 |
await 写在 forEach 里 | forEach 不等待异步回调,循环结束就返回了 | 用 for...of 串行,或 Promise.all(arr.map(...)) 并行 |
循环里逐个 await | 无依赖却串行,耗时线性叠加 | 确认无依赖后改 Promise.all |
.then 里 return promise 却忘了链式返回 | 外层拿到的是 undefined,时序错乱 | return 出来,或直接用 await |
new Promise 包一层已经返回 Promise 的 API | 冗余且容易丢错误(Promise 构造器反模式) | 直接 return fetch(...) |
在 Promise 构造器里 async executor | executor 里的 await 抛错无法被 catch 到 | executor 保持同步,只在里面调 resolve/reject |
只写 try 不写 catch 就 await | 错误冒泡成 unhandledRejection(Node 默认会终止进程) | 显式 catch,或注册全局 unhandledRejection 处理器记录日志 |
用 setTimeout(fn, 0) 做「立刻执行」 | 至少 0~4ms 延迟,还排在所有微任务后面 | 用 queueMicrotask(fn) |
递归 process.nextTick | 事件循环饥饿,I/O 永远不执行 | 改用 queueMicrotask 或 setImmediate |
Promise.all 里混入可能失败的非关键任务 | 一个失败导致整体失败,其他成功结果全丢 | 关键用 all,非关键用 allSettled |
未处理的拒绝(Unhandled Rejection)
在 Node.js 中,一个既没有
catch、也没有全局处理器的 Promise 拒绝会导致进程退出(默认
--unhandled-rejections=throw,见 Node.jsprocess文档的'unhandledRejection'事件)。生产环境应当在进程入口注册处理器,把原因记入日志,而不是靠它来「恢复运行」。
四、怎么用:一个端到端的可运行例子
需求:并发抓取 12 个接口,最多同时 4 个,任一个失败不影响其余,全部完成后统计成功与失败,整体超时 2 秒。
// 运行环境:Node.js 18+(用到全局 fetch),`node demo.mjs`
// 把 URL 换成自己项目的接口即可直接复用
// ——— 复用上一节的 pLimit ———
function pLimit(concurrency) {
const queue = [];
let activeCount = 0;
const next = () => {
activeCount--;
if (queue.length) queue.shift()();
};
return (fn) => new Promise((resolve, reject) => {
queue.push(async () => {
activeCount++;
try { resolve(await fn()); } catch (e) { reject(e); } finally { next(); }
});
if (activeCount < concurrency) queue.shift()();
});
}
const limit = pLimit(4);
/** 带超时的单个请求:成功返回数据,失败抛出 Error —— 由调用方决定如何处理 */
async function fetchWithTimeout(url, ms) {
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), ms);
try {
const res = await fetch(url, { signal: controller.signal });
if (!res.ok) throw new Error(`${url} 返回 HTTP ${res.status}`);
return await res.json();
} finally {
clearTimeout(timer); // 避免请求已结束后仍触发 abort
}
}
async function main() {
const urls = Array.from({ length: 12 }, (_, i) =>
`https://jsonplaceholder.typicode.com/todos/${i + 1}`);
const settled = await Promise.allSettled(
urls.map((url) => limit(() => fetchWithTimeout(url, 2000))),
);
// 用 reduce 统计,比手动维护计数器更不容易写错
const { ok, failed } = settled.reduce(
(acc, r) => {
if (r.status === 'fulfilled') acc.ok.push(r.value.id);
else acc.failed.push(r.reason.message);
return acc;
},
{ ok: [], failed: [] },
);
console.log(`成功 ${ok.length} 个:`, ok);
if (failed.length) console.warn(`失败 ${failed.length} 个:`, failed);
}
main().catch((err) => {
// 兜底:任何意外都不让它变成 unhandledRejection
console.error('未预期的错误:', err);
process.exitCode = 1;
});
这段代码体现的四个模式值得记住:
pLimit控制并发:不炸接口、不触发浏览器连接数限制。AbortController做真实超时:不只是"不再等待",而是真正中断请求,释放连接。allSettled保证部分成功可用:批量任务用allSettled通常比all更合适。- 顶层
catch兜底:绝不让 Promise 拒绝逃逸成进程崩溃。
五、注意事项与常见坑
十个高频错误
1.
await忘了写:fetchUser()返回 Promise,console.log(fetchUser())打印Promise { <pending> }。2.
Array.prototype.forEach+async:forEach会忽略回调返回的 Promise,循环「立刻结束」。3.
try/catch包不住没await的 Promise:try { doAsync(); } catch {}永远捕获不到。4. 误以为
Promise.all会取消其他任务:它只是「不再关心」,请求仍在后台跑完。5. 误以为
Promise.race只认成功:谁先落定谁赢,包括失败者,所以超时用它要小心。6.
res.json()忘了await:拿到的是 Promise 而非数据。7.
setTimeout(fn, 0)当作「立即执行」:实际在微任务之后,且受 4ms 嵌套钳制。8.
async函数作为事件监听器:addEventListener不处理返回的 Promise,拒绝会变成未处理拒绝。9. 在
Promise构造器里做重活:executor 是同步执行的,写在这里的同步计算依然阻塞主线程。10. 依赖
setTimeout的精确延时:定时器只保证「不早于」,不保证「准时」。
调试技巧
- 输出顺序类问题,用
console.log+ 编号手工推演一遍微任务/宏任务队列,比盯着代码看快得多。- 断点打在
then回调里,DevTools 的 Async 调用栈可以回溯到发起异步的位置。- Node.js 里加
--trace-warnings能看到「哪个 Promise 被拒绝却没处理」的详细信息。
六、练习题
题 1(事件循环输出顺序,必做)
下面代码在浏览器控制台中的输出顺序是什么?先自己写下答案再运行验证。
console.log(1);
setTimeout(() => console.log(2), 0);
Promise.resolve().then(() => console.log(3));
(async () => {
console.log(4);
await null;
console.log(5);
await Promise.resolve();
setTimeout(() => console.log(6), 0);
console.log(7);
})();
setTimeout(() => console.log(8), 0);
Promise.resolve().then(() => console.log(9)).then(() => console.log(10));
for (let i = 11; i <= 13; i++) console.log(i);
<details>
<summary>答案与逐步推演(点开)</summary>
输出顺序:1 4 11 12 13 3 5 9 7 10 2 8 6
(本题已用 Node.js 实测确认,输出为 1 4 11 12 13 3 5 9 7 10 2 8 6;浏览器中顺序一致。)
推演:
- 同步阶段按书写顺序执行:
1setTimeout(() => 2)→ 宏任务队列[2].then(() => 3)→ 微任务队列[3]- async IIFE 是「立即调用」,本轮同步执行到第一个
await才让出 → 打印4,在await null处暂停 setTimeout(() => 8)→ 宏任务队列[2, 8].then(() => 9).then(() => 10)→ 微任务队列[3, 9]- for 循环 →
11 12 13
- 清空微任务队列(初始为
[3, 9, async续体①]),按 FIFO 顺序:
3的回调 → 打印39的回调 → 打印9,并把10的回调注册到队尾- async 续体① → 打印
5;接着遇到await Promise.resolve(),让出并把续体②注册到队尾 - 此时队列为
[10的回调, async续体②]
- 继续清空微任务队列:
10的回调 → 打印10- async 续体② → 先执行
setTimeout(() => 6, 0),把6追加到宏任务队尾,再打印7
- 微任务清空完毕。宏任务队列此刻是
[2, 8, 6],依次执行 →2、8、6。
两个易错点:
- 以为
async函数体是「异步开始」的,从而把4排到11 12 13之后。
实际上 async 函数调用时函数体同步执行,只在遇到 await 时才让出。
- 以为
setTimeout(fn, 0)注册得早就一定先执行。【6】是在第 3 步(微任务阶段)才注册的,
所以它排在【2】【8】之后——定时器的顺序由入队时刻决定,而不是回调里写的延迟值。
</details>
题 2(Promise 状态机)
await 一个已经 rejected 的 Promise,并用 try/catch 捕获;如果同一个 rejected Promise 被 await 两次,
第二次还会进入 catch 吗?为什么?
<details>
<summary>提示</summary>
会的。Promise 的状态与原因一旦落定就永久冻结,任何时刻、任何数量的 then/await 都能读到同一个拒绝原因。
这也是「Promise 可以多播(multicast)」的含义——与回调只能被调用一次不同。
</details>
题 3(并发改写)
下面的函数需要抓 200 个用户,但接口限流为「每秒最多 10 个请求」。请改写它,
要求总耗时可接受且不触发限流。
async function loadAll(ids) {
const out = [];
for (const id of ids) out.push(await fetchUser(id)); // 串行,极慢
return out;
}
<details>
<summary>参考答案</summary>
用 pLimit(10) 限制并发,并叠加「每批之间等待 1 秒」或「令牌桶」策略:
// 运行环境:Node.js 18+(pLimit 沿用 3.5 节的定义)
async function loadAllThrottled(ids) {
const limit = pLimit(10);
const chunks = [];
for (let i = 0; i < ids.length; i += 10) chunks.push(ids.slice(i, i + 10));
const out = [];
for (const chunk of chunks) {
// 每批 10 个并发,批间等 1 秒 —— 满足「每秒最多 10 个」
out.push(...(await Promise.all(chunk.map((id) => limit(() => fetchUser(id))))));
await new Promise((r) => setTimeout(r, 1000));
}
return out;
}
注意
...await的括号
out.push(...await Promise.all(...))在多数运行环境下能解析,但
...await连写的解析涉及await与展开运算符的优先级,加一层括号写成...(await ...)更稳、可读性也更好。
注意点:pLimit(10) 保证同时在跑的不超过 10 个,但只要任务足够快,一秒内仍可能跑完好几批——
所以真实限流要么按时间窗口计数(令牌桶),要么按批 + 批间休眠。生产环境更推荐使用成熟的限流库。
</details>
题 4(手写题)
不使用 Promise.all,实现一个 myAll(promises),行为与 Promise.all 一致(含「空数组立刻 fulfilled」与「顺序与输入一致」)。
<details>
<summary>参考答案</summary>
// 运行环境:Node.js 18+
function myAll(iterable) {
const items = [...iterable];
return new Promise((resolve, reject) => {
const results = new Array(items.length);
let remaining = items.length;
if (remaining === 0) return resolve(results); // 空数组:立刻成功
items.forEach((item, i) => {
// 用 Promise.resolve 包一层,兼容非 Promise 的普通值
Promise.resolve(item).then(
(v) => {
results[i] = v; // 按索引写入 → 顺序与输入一致
if (--remaining === 0) resolve(results);
},
reject, // 任意一个失败:立刻整体失败
);
});
});
}
console.log(await myAll([1, Promise.resolve(2), 3])); // [ 1, 2, 3 ]
console.log(await myAll([])); // []
</details>
题 5(思考题)
setTimeout(fn, 0) 与 queueMicrotask(fn) 都能实现「当前代码之后执行」。请说明各自适用的场景,
并解释为什么把大循环切片时应该用 setTimeout 而不是 queueMicrotask。
<details>
<summary>参考思路</summary>
queueMicrotask 在当前宏任务结束后、渲染之前执行,且会把微任务队列跑干净——
如果用它在循环里递归切片,等于在同一个宏任务里连续跑完全部切片,渲染永远等不到机会,页面照样卡死。
setTimeout(fn, 0) 每次都会产生一个新的宏任务,宏任务之间浏览器才有机会渲染与处理用户事件,
所以「让出主线程」必须用宏任务。(代价是最小 4ms 的嵌套延迟。)
</details>
七、常见问题(FAQ)
Q1:Promise 是「多线程」吗?它到底在哪里执行?
A:不是。Promise 只是状态机 + 回调调度器,它的回调永远在主线程上执行。
真正「并行」的部分发生在宿主环境(网络线程、文件 I/O 线程、定时器线程),
主线程只负责在合适的时机把回调取回来跑。所以 new Promise 里写 while(true) 一样会卡死页面。
Q2:async 函数和 Promise 有性能差别吗?
A:几乎没有。async/await 是建立在 Promise 之上的语法糖(V8 内部还会做优化)。
差别主要在可读性与错误处理:await 能用 try/catch,then 链需要 .catch。
性能上真正要关心的是「有没有把能并行的任务写成了串行」,而不是选哪种语法。
Q3:为什么 setTimeout(fn, 0) 有时延迟十几毫秒?
A:三个因素叠加:①它是宏任务,要等当前宏任务与所有微任务跑完;
②嵌套超过 5 层后最小延迟被钳制为 4ms;
③渲染、其他宏任务、浏览器自身的调度都会插在前面。
定时器只保证「不早于」,不保证「准时」,任何依赖精度的逻辑(如动画)都应该用 requestAnimationFrame。
Q4:await 会让出主线程,是不是等于「不阻塞」?
A:不等于。await 只是让当前函数暂停,主线程照样在跑别的任务;
而 await 之后恢复执行的那段代码依然是同步阻塞的。
如果你 await 一个耗时 5 秒的纯计算(await heavyCompute()),主线程照样卡 5 秒——
因为计算本身在调用时就同步开始了。真正的解法是把计算切分,或搬到 Web Worker / Worker Threads。
相关笔记
- JavaScript-02-函数与作用域:闭包与
this是理解回调、Promise链中上下文的前提 - JavaScript-05-DOM与事件:事件监听器本质上也是异步回调,事件循环是事件模型的地基
- JavaScript-06-模块化与工程化:ESM 的顶层
await、打包工具对异步代码的处理 - 后端-02-Nodejs与Express:Node.js 事件循环的六个阶段与中间件里的异步写法
- CSharp-05-异步编程:对比
Task/async/await与 JS 的异同,理解「语言级协程」与「事件循环」的区别
参考来源
- MDN 中文:《使用 Promise》 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Using_promises
- MDN 中文:
Promisehttps://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise - MDN 中文:
Promise.allSettled()(含四种组合方法的行为定义) https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled - MDN 中文:
Promise.any()(AggregateError行为) https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/any - MDN 中文:
async function声明 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/async_function - MDN 中文:
for await...ofhttps://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/for-await...of - MDN 中文:
AbortControllerhttps://developer.mozilla.org/zh-CN/docs/Web/API/AbortController - MDN 中文:
setTimeout()(嵌套 4ms 最小延迟的规范说明) https://developer.mozilla.org/zh-CN/docs/Web/API/Window/setTimeout - 现代 JavaScript 教程(中文):《事件循环:微任务和宏任务》 https://zh.javascript.info/event-loop
- 现代 JavaScript 教程(中文):《Promise API》 https://zh.javascript.info/promise-api
- ECMAScript 规范:Control Abstraction Objects(Promise 与 Await 的抽象操作) https://tc39.es/ecma262/multipage/control-abstraction-objects.html
- Node.js 官方文档:
process.nextTick与queueMicrotask的取舍、'unhandledRejection'事件 https://nodejs.org/docs/latest/api/process.html - Node.js 官方文档:Timers(
setImmediate与事件循环阶段) https://nodejs.org/docs/latest/api/timers.html - 说明:
AbortSignal.timeout/AbortSignal.any等较新 API 的浏览器支持情况易变,请以 MDN 与目标运行环境的最新文档为准。