一个首页要同时拉用户信息、订单列表、公告三条数据。为了快,用了 Promise.all:
const [user, orders, notices] = await Promise.all([
fetch("/api/user").then((r) => r.json()),
fetch("/api/orders").then((r) => r.json()),
fetch("/api/notices").then((r) => r.json())
]);
上线后某天公告服务挂了,返回 500。结果不是「公告那块空着」,而是整个首页白屏——Promise.all 只要有一个失败,整体就进入失败状态,已经成功的那两条数据也拿不到。
这类问题的根源是把「一起等」和「一个都不能少」当成了一回事。异步这块的知识点不多,但组合起来的选择很多,选错就是线上事故。
这篇讲什么:Promise 的三个状态、链式调用怎么往下传、错误是怎么一层层流到 catch 的、async/await 和 Promise 是什么关系、并发请求该用哪个组合方法,以及几个最常见的坑。读完你能做到:写请求时不再漏 catch;知道什么时候该串行、什么时候该并发;看到「Uncaught (in promise)」能定位到哪一段没接住。
Promise 就是一个「将来会有结果」的占位
发起一个请求,结果不会立刻回来。Promise 就是先给你一张凭证:现在没有值,将来要么给你值,要么给你一个错误。它只有三种状态:
| 状态 | 含义 | 之后会怎样 |
|---|---|---|
pending | 等待中,还没有结果 | 可能变成成功,也可能变成失败 |
fulfilled | 成功,带着结果值 | 状态固定,then 能拿到值 |
rejected | 失败,带着原因(通常是一个 Error) | 状态固定,catch 能拿到原因 |
状态只能从 pending 变一次,成功或失败之后不会再变。所以一个 Promise 可以被多处 then,拿到的是同一个结果。
const p = new Promise((resolve, reject) => {
setTimeout(() => resolve("数据到了"), 1000);
});
p.then((value) => console.log(value)); // 1 秒后打印:数据到了
p.then((value) => console.log(value)); // 同一个结果,也能拿到
// 手动造一个失败
const fail = Promise.reject(new Error("出错了"));
fail.catch((err) => console.log(err.message)); // 出错了
日常写业务基本不用自己 new Promise,因为 fetch、定时器封装、文件读取这些 API 已经返回 Promise 了。需要自己包的场景通常是「把回调式的老 API 转成 Promise」,比如某些 SDK 的 success/error 回调。
fetch 有个容易误会的地方:只有网络层失败(断网、DNS 失败)才 reject;服务器返回 404、500,它仍然算「成功」,只是 response.ok 是 false。不检查 ok 就直接 json(),会把错误页当正常数据解析。还有一个细节:传给 new Promise 的那个函数是立刻同步执行的,不是等 then 时才跑。所以下面这段会先打印「开始」,再打印「回调」:
console.log("开始");
const p = new Promise((resolve) => {
console.log("回调");
resolve(1);
});
p.then((value) => console.log("then", value));
// 输出顺序:开始、回调、then 1
这条规则影响很大:在构造函数里做耗时操作(读大文件、跑一个长循环),会卡住当前线程,Promise 并不会把它变异步。异步的来源是 setTimeout、网络、文件读取这些底层能力,Promise 只是装结果的容器。
自己包老 API 时,最容易漏的是失败分支。比如某 SDK 给的是 pay(order, onSuccess, onFail),包装时只写了 onSuccess: resolve,忘了 onFail: reject,这个 Promise 就永远停在 pending,调用方的 await 会一直挂着,既不成功也不失败。这类包装写完,要专门造一次失败去试,别只跑通成功路径。
then 链:每一步返回什么,下一步就收到什么
then 返回的是一个新的 Promise,所以可以链下去。链条上的值怎么传,规则就一条:上一个回调的返回值,就是下一个回调的参数。
fetch("/api/user")
.then((response) => {
if (!response.ok) throw new Error("HTTP " + response.status);
return response.json(); // 返回 Promise,下一步等它完成
})
.then((user) => {
console.log(user.name); // 这里拿到解析后的对象
return user.id; // 返回普通值,下一步直接收到
})
.then((id) => {
return fetch("/api/orders?userId=" + id);
})
.then((response) => response.json())
.catch((err) => {
console.error("加载失败", err.message);
})
.finally(() => {
hideLoading(); // 成功失败都会执行
});
两个关键点。第一,回调里 return 一个 Promise,链条会等它完成再把结果交给下一步;不 return 的话,下一步收到的是 undefined,而且不会等。第二,catch 能接住它前面任何一步的错误,包括 then 里手动 throw 的。
错误会沿链往下找最近的 catch。中间某个 then 抛错,后面的 then 全部跳过,直接进 catch。这既是优点也是坑:链条很长时,一个错误会让后面所有步骤静默不执行,日志里只有一行,不容易看出断在哪一步。
catch 执行完,链条会回到「成功」状态,后面的 then 照样执行。这一点可以用来做降级:
fetch("/api/notices")
.then((response) => response.json())
.catch(() => []) // 公告失败给空数组
.then((list) => renderNotices(list)); // 这里一定会执行
但要清楚代价:降级之后,renderNotices 分不清「真的没有公告」和「公告加载失败」。这两种情况 UI 要显示不同文案,就在 catch 里把状态一起传下去,比如返回 { items: [], failed: true }。
还有一点容易记反:then(onFulfilled, onRejected) 的第二个参数只接「这一步之前」的错误,接不住同一个 then 里 onFulfilled 自己抛出的错。所以统一用末尾的 catch 更省心,整条链上的错误都落到同一个地方。
async/await 只是更好读的写法
async 函数一定返回 Promise;await 等一个 Promise 出结果,成功就把值拿出来,失败就当场抛异常。上面那段链式,用 async/await 写是这样:
async function loadOrders() {
try {
const res = await fetch("/api/orders");
if (!res.ok) throw new Error("HTTP " + res.status);
const orders = await res.json();
return orders;
} catch (err) {
console.error("加载失败", err.message);
return []; // 明确给调用方一个兜底值
} finally {
hideLoading();
}
}
读起来像同步代码,但本质没变:函数仍是异步的,await 只是把「等结果」这件事写得更直白。所以看到 async 函数,要记得它返回的永远是 Promise,调用方要么 await,要么 .then。
三个常被忽略的点:
catch 只包住 await 的错误
try/catch 能接住 await 的失败,但接不住「你忘了 await」的 Promise。后者会变成未处理的 rejection,控制台报 Uncaught (in promise)。
返回值会被自动包装
async 函数里 return 1,调用方拿到的是 Promise.resolve(1)。所以别在 async 函数里再手动 return Promise.resolve(x),多余。
串行和并发的差别
写成一排 await 就是串行,后一个等前一个。互不依赖的请求这样写,时间会累加;要并发,先把 Promise 都创建出来,再统一 await。
await 不只能等 Promise。等一个普通值,它直接返回那个值,不会多花一帧;等一个 thenable(带 then 方法的对象),它按 Promise 处理。所以 await 1 是合法的,只是没意义。
另一个容易忽略的点:async 函数里的 throw 不会同步抛给调用方,而是变成一个 rejected 的 Promise。调用方没有 await 的话,外面的 try/catch 接不到:
async function check() {
throw new Error("库存不足");
}
try {
check(); // 少了 await,错误漏出去
} catch (err) {
console.log("这里不会执行");
}
这和第 1 节「状态只变一次」是同一件事的两面:异步函数的失败也是「将来的结果」,必须有人去等它。
并发:all、allSettled、race、any 怎么选
这几个方法名字接近,行为差别不小,选错就是开头那种事故:
| 方法 | 什么时候结束 | 结果 | 典型场景 |
|---|---|---|---|
Promise.all | 全部成功,或任意一个失败 | 成功时是结果数组;失败时直接 reject,只给第一个错误 | 缺一不可的数据,比如页面初始化 |
Promise.allSettled | 全部结束(不管成功失败) | 每项是 { status, value } 或 { status, reason } | 几个模块互不强依赖,失败的那块降级 |
Promise.race | 第一个结束的 | 跟第一个的结果走,成功或失败都算 | 超时控制、多个源抢最快 |
Promise.any | 第一个成功的 | 成功时给那个值;全失败才 reject | 多个备用接口,有一个能用就行 |
把开头首页的例子改成 allSettled,公告挂了不影响其他两块:
const results = await Promise.allSettled([
fetch("/api/user").then((r) => r.json()),
fetch("/api/orders").then((r) => r.json()),
fetch("/api/notices").then((r) => r.json())
]);
const data = { user: null, orders: [], notices: [] };
results.forEach((item, index) => {
if (item.status === "fulfilled") {
data[["user", "orders", "notices"][index]] = item.value;
}
});
console.log(data.orders); // 公告失败也能拿到订单
上面用下标去对应字段,实际项目里更稳的写法是按名字建表,以后加接口不用同步改两处:
const tasks = {
user: fetch("/api/user").then((r) => r.json()),
orders: fetch("/api/orders").then((r) => r.json()),
notices: fetch("/api/notices").then((r) => r.json())
};
const keys = Object.keys(tasks);
const settled = await Promise.allSettled(Object.values(tasks));
const data = {};
settled.forEach((item, i) => {
data[keys[i]] = item.status === "fulfilled" ? item.value : null;
});
if (data.notices === null) {
console.warn("公告没加载出来,已降级");
}
allSettled 不会告诉你「失败的比例」。三个接口挂两个,它照样安静地返回,页面可能只剩一块内容。所以拿到结果后要自己统计失败数,超过阈值就整块提示或上报,别把全部失败当成正常。
用 race 做超时是很实用的小工具:
function timeout(ms) {
return new Promise((resolve, reject) => {
setTimeout(() => reject(new Error("请求超时")), ms);
});
}
try {
const data = await Promise.race([
fetch("/api/slow").then((r) => r.json()),
timeout(3000)
]);
console.log(data);
} catch (err) {
console.error(err.message); // 请求超时
}
注意 race 不会取消那个慢请求,只是你不再等它了。真要取消得用 AbortController,属于请求层的知识,这里不铺开。
上面那个超时实现还有个小泄漏:请求先回来时,定时器仍在跑,要等 3 秒才释放。单个页面无所谓,但如果一次发几十个请求,就会挂着几十个没用的定时器。改成能清理的版本:
function withTimeout(promise, ms, message) {
let timer;
const guard = new Promise((resolve, reject) => {
timer = setTimeout(() => reject(new Error(message || "请求超时")), ms);
});
return Promise.race([promise, guard]).finally(() => clearTimeout(timer));
}
const data = await withTimeout(
fetch("/api/slow").then((r) => r.json()),
3000
);
这里 finally 挂在 race 的结果上,谁先结束都会清掉定时器。guard 这个 Promise 负责计时,它自己不接触业务数据,失败时的错误信息也统一,不会和业务错误混在一起。
几个高频坑
第一,忘记 await。函数照常往下走,你以为拿到了数据,其实拿到的是 Promise:
async function save() {
const res = fetch("/api/save"); // 少了 await
console.log(res.ok); // undefined,res 是 Promise
}
// 正确
async function save2() {
const res = await fetch("/api/save");
console.log(res.ok); // true
}
第二,在 forEach 里 await。前面循环那篇提过,forEach 不会等回调里的 Promise:
// 不会等任何一条保存完
list.forEach(async (item) => {
await save(item);
});
// 串行:一条一条来
for (const item of list) {
await save(item);
}
// 并发:都发出去,统一等
await Promise.all(list.map((item) => save(item)));
第三,catch 里什么都不做:
try {
await save(data);
} catch (err) {
// 空着
}
错误被吞掉,页面没反应,用户以为保存成功。至少记一条日志;如果业务上可以忽略,写注释说明为什么忽略,别让下一个人猜。
第四,在 new Promise 的构造函数里写异步回调时忘记 reject。比如老 SDK 的 success 分支写了 resolve,fail 分支只打印日志,这个 Promise 就永远停在 pending,调用方的 await 会一直挂着。
第五,async 函数里忘了 return。下面这个函数,调用方 await 之后拿到的是 undefined,不是数据:
async function getOrders() {
const res = await fetch("/api/orders");
res.json(); // 少了 return
}
const orders = await getOrders();
console.log(orders); // undefined
这种错不报任何异常,只会在下游某个 orders.map 的地方炸掉,排查时容易往接口上想。写完在调用处打印一次返回值,比读代码快。
第六,把旧 Promise 塞进新数组,以为是在「重新请求」。Promise 是一次性的凭证,状态定了就不会重来;你重新 await 它,拿到的还是上次的结果。要重新请求,就重新调用 fetch,别复用旧的那个对象。
和事件循环的关系,先知道结论
await 之后的代码不会立刻执行,它要等当前同步代码跑完,作为「微任务」排进队列。所以下面这段的输出顺序常被问:
console.log("1");
setTimeout(() => console.log("2"), 0);
Promise.resolve().then(() => console.log("3"));
console.log("4");
// 实际输出:1 4 3 2
原因:同步代码先跑完(1、4),然后清空微任务队列(3),最后才轮到宏任务(2)。await 后面的代码也属于微任务,所以它总是排在本轮同步代码之后、定时器之前。
再补一个常见误区:await 之后的代码是微任务,但「微任务」不等于「下一帧」。如果 await 后面紧接着改 DOM,浏览器不会立刻渲染,它要等当前任务和微任务队列都清空。连着 await 三次再一次性改 DOM,中间不会出现三次画面。
如果只是想「让出当前调用栈、稍后再执行」,用 queueMicrotask 比 Promise.resolve().then 更直白,两者在微任务队列里的位置基本一致。真正要等下一帧再做动画,用 requestAnimationFrame,不要用 setTimeout(0) 猜。
这个机制值得单独一篇文章讲,包括任务队列、渲染时机、requestAnimationFrame 的位置。这里先记住结论就好,细节在浏览器那组文章里展开,避免一下子塞太多。
完整场景走查:客服工作台首页怎么从 2.8 秒做到 0.9 秒
需求很普通:客服打开工作台,一次看到四块内容,分别是自己的账号状态、待处理工单、系统公告、今日统计。四个接口:
| 接口 | 返回 | P99 耗时 | 失败影响 |
|---|---|---|---|
/api/agent/profile | { id, name, status, maxConcurrent } | 200ms | 整页不可用,必须重试 |
/api/tickets?status=pending&page=1&size=20 | { total, items },一页 20 条 | 300ms | 列表区降级,其它块可用 |
/api/notice | { html, updatedAt } | 50ms,偶发 502 | 公告区显示「加载失败」,不影响操作 |
/api/stats/today | { solved, avgReplySeconds, satisfaction } | 800ms(走聚合查询) | 数字显示「--」,可稍后重试 |
量级:早高峰同时在线客服 300 人左右,9:00 到 9:10 集中登录;工单表当天新增 1.2 万条;公告接口对接的是老系统,没有 SLA 承诺。
第一版这么写,本地能跑,测试也挑不出毛病:
async function init() {
showLoading();
const profile = await fetch("/api/agent/profile").then((r) => r.json());
const tickets = await fetch("/api/tickets?status=pending&page=1&size=20").then((r) => r.json());
const notice = await fetch("/api/notice").then((r) => r.json());
const stats = await fetch("/api/stats/today").then((r) => r.json());
renderProfile(profile);
renderTickets(tickets);
renderNotice(notice);
renderStats(stats);
hideLoading();
}
本地四个接口都在 20ms 内,看起来没问题。上线第一个周一,四个问题叠在一起爆发:
- 首屏慢。四个请求串行,P99 相加 200 + 300 + 50 + 800 已经是 1.35 秒,早高峰网络抖动时实测首屏 2.8 秒。客服一天要刷新十几次,抱怨很集中。
- 公告 502 时整页白屏。网关返回的 HTML 错误页被当成 JSON 解析,
r.json()抛错,init直接 reject。hideLoading在最后一行,永远不会执行。 - 统计接口卡住时,页面停在 loading 六秒以上。没有超时控制,只能等浏览器自己断开连接。
- 登录态过期,网关 302 到登录页并返回 HTML,控制台报
Unexpected token '<',用户看到的是加载转圈,不知道该重新登录。
改的时候别一次全改,按影响排序:先把串行改并发,再给每个请求加超时,然后把「整页一起渲染」拆成「分块渲染、分块降级」,最后补登录态判断和防重复。第一步的公共请求函数长这样:
async function getJSON(url, ms = 3000) {
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), ms);
try {
const res = await fetch(url, { signal: controller.signal });
if (res.status === 401) {
location.replace("/login?next=" + encodeURIComponent(location.pathname));
throw new Error("未登录");
}
if (!res.ok) throw new Error("HTTP " + res.status + " " + url);
return await res.json();
} finally {
clearTimeout(timer);
}
}
这里用 AbortController 而不是 Promise.race,原因是 race 只是「不再等」,请求还在后台跑。早高峰 300 个人同时超时,服务端会堆着 300 个没人要的查询;abort 能把连接真正断掉,也能让服务端少做一段无用功。
然后是并发和分块渲染。四个请求同时在飞,谁先回来先渲染谁,失败的那块留占位和重试按钮:
async function init() {
showLoading();
const tasks = {
profile: getJSON("/api/agent/profile", 2000),
tickets: getJSON("/api/tickets?status=pending&page=1&size=20", 2500),
notice: getJSON("/api/notice", 1500),
stats: getJSON("/api/stats/today", 3000)
};
// 每个请求各自兜底,失败转成正常对象,不拖累别人
const safe = (name, promise) => promise.then(
(value) => ({ name, value, ok: true }),
(reason) => ({ name, value: null, ok: false, reason })
);
const results = await Promise.all(
Object.entries(tasks).map(([name, promise]) => safe(name, promise))
);
const data = {};
const failed = new Set();
results.forEach((item) => {
data[item.name] = item.value;
if (!item.ok) {
failed.add(item.name);
console.warn("模块加载失败", item.name, item.reason);
}
});
hideLoading();
if (failed.has("profile")) {
renderProfileError(); // 刚需数据没了,整页提示加重试
return;
}
renderProfile(data.profile);
renderTickets(data.tickets || { total: 0, items: [] }, failed.has("tickets"));
renderNotice(data.notice, failed.has("notice"));
renderStats(data.stats, failed.has("stats"));
}
为什么这里用 Promise.all 而不是 allSettled:每个任务已经用 safe 把失败转成了正常对象,all 里不会再有 rejected 的项,既保住「全部结束」的等待语义,又留下了每块的失败原因。两种写法都对,关键是别让一个失败把其它数据一起带走。
实际效果:首屏从 2.8 秒降到 0.9 秒左右,上限由最慢的统计接口 800ms 决定;公告挂掉时其余三块正常显示,公告区是一行灰字加「重试」;统计超时显示 --。上线一周没再出现整页白屏。
最后补一个细节:重试按钮要防重复。连点三次会发三轮请求,后回来的旧响应还可能覆盖新数据。用一个模块级标记挡住:
let ticketLoading = false;
async function reloadTickets(btn) {
if (ticketLoading) return; // 上一轮还没结束
ticketLoading = true;
btn.disabled = true;
try {
const data = await getJSON("/api/tickets?status=pending&page=1&size=20", 2500);
renderTickets(data, false);
} catch (err) {
showBlockError("工单列表", err);
} finally {
ticketLoading = false;
btn.disabled = false;
}
}
btn.disabled 只解决了「同一个按钮被连点」,标记才解决「不同入口同时刷新」。两者都要,因为键盘回车、快捷键、另一个页面切回来的自动刷新,都可能绕开按钮状态。
错误现象对照
异步出问题,报错往往不在出问题的那一行。下面这张表按「你看到什么」反查,比从代码第一行读起快。用法是先确认现象,再验证原因,别反过来先猜结论。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
页面没反应,控制台一条 Uncaught (in promise) TypeError: Failed to fetch |
请求失败了,但发起处没 await 也没接 catch;也可能是断网、跨域预检没过 |
Network 里看这条请求的状态是 (failed)、pending 还是 4xx;再看 Console 第一条错误的堆栈里有没有自己的文件 |
| 整页空白,但 Network 里四个接口全是 200 | 某个响应缺字段,渲染函数里取属性抛错。这类错误发生在同步渲染里,不在 Promise 里 | 看 Console 第一条 TypeError,展开 stack 找第一个自己的文件名和行号,把那一行的对象打印出来 |
| loading 一直转,接口其实早就返回了 | 某个 Promise 永远 pending:老 SDK 只写了 success 没写 fail,或 await 了一个不会 resolve 的 Promise |
在 finally 和每个分支加日志,看哪一步没走到;Network 里看有没有一直挂着的请求 |
| 首屏 3 秒,Network 瀑布图上四个请求一个接一个 | 串行 await。每个请求的起点都在上一个的结束点之后 |
看 Timing 列:如果一个请求的 Stalled 紧接在上一个的完成时间,基本可以确认是串行 |
| 公告接口 500,订单列表也跟着空了 | 用了 Promise.all,一个 reject 导致整体 reject,已经成功的结果也丢了 |
全局搜 Promise.all,逐个确认这几个请求是不是真的「缺一不可」 |
控制台报了 HTTP 500,页面上显示「暂无数据」 |
catch 里 return 了 [] 或 {},UI 把「失败」当成了「空」 |
看 catch 的返回值有没有带失败标记,再搜这个兜底值被谁消费 |
| 点一次「重试」,Network 里出现两组一模一样的请求 | 按钮没防重复,或者在飞的旧请求没取消;也可能是重试函数被绑了两次 | 看两条请求的时间差是否在几十毫秒内;在函数入口打印一行固定字符串,数打印次数 |
最容易误判的是第二行。接口全 200,人会下意识觉得「数据没问题」,转头去查组件和样式。实际上 200 只说明 HTTP 层成功,业务字段缺不缺是另一回事。养成一个习惯:渲染函数入口先打印一次入参的 Object.keys,缺字段一眼就能看到。
边界与代价:什么时候别这么写
Promise 和 async/await 解决的是「等待」,不是「变快」。有几类场景套上去反而更糟:
- CPU 密集的计算。把大数组排序、解析 20MB 的 JSON 包进
async函数,主线程照样卡死,只是外面多了一层 Promise。要真正不阻塞,只能用 Worker。 - 有严格先后顺序的写操作。下单、扣库存、状态流转必须串行,还要考虑失败回滚。用
Promise.all并发提交五个写请求,成功三个失败两个,数据就半截了。 - 同一资源的并发写。两个请求同时改同一条记录的同一个字段,谁后到谁生效。这不是异步的错,但并发把它放大了。
- 「发出去就不管」的操作。收藏、埋点这类不需要结果,仍然要接
catch,否则失败会变成unhandledrejection噪音。
再说数据量。并发不是「越多越快」,浏览器对同域请求有连接数限制,HTTP/1.1 下 Chrome 是 6 个。一次 Promise.all 塞 60 个请求,并不是 60 个同时在跑,而是 6 个在跑、54 个排队。如果你给每个请求都设了 3 秒超时,排队那批从「创建时」就开始计时,还没轮到发送就已经超时了。现象是「明明接口很快,却报了一堆超时」。
所以超过 20 个请求就该分批或限流。一个能直接用的版本:
async function mapLimit(list, limit, task) {
const results = new Array(list.length);
let next = 0;
const workers = Array.from(
{ length: Math.min(limit, list.length) },
async () => {
while (next < list.length) {
const i = next++;
results[i] = await task(list[i], i);
}
}
);
await Promise.all(workers);
return results;
}
// 200 张图片上传,最多 4 个同时跑,结果顺序和原数组一致
const uploaded = await mapLimit(images, 4, (file) => upload(file));
next++ 是同步执行的,多个 worker 不会拿到同一个下标;结果按下标写回,顺序不会乱。如果其中一张失败,整个 mapLimit 会 reject,其它还在跑的会上传完但结果没人接。需要「部分成功」,就在 task 里自己 try/catch,返回 { ok: false, file }。
嵌套深度也有阈值。then 链超过四五段,读代码的人就要来回跳;错误一旦发生,只知道「链断了」,不知道断在第几段。我的做法是超过三段就拆成具名函数,一个函数只做一件事,出错时堆栈里能看到函数名。嵌套的 async 函数同理,async 会传染:一个函数变成异步,调用它的函数也得等,一层层往上,直到最外层的事件处理函数。这不是 bug,但要在边界处有意识收口。
还有一些隐形成本,平时不显,出问题时很难查:
catch 里重新 throw new Error("加载失败"),原始堆栈就没了。要保留就写 new Error("加载失败", { cause: err }),较新的浏览器支持 cause,日志里能带出原始错误。allSettled 把所有成功的结果留在数组里,直到你处理完。20 个接口每个返回 5MB,峰值就是 100MB。大响应要及时取用、及时释放引用。setInterval,上一轮没结束下一轮又开始,请求越积越多。改成递归 setTimeout,等上一轮结束再排下一次。await 之后时,调用栈里已经看不到发起时的上下文。排查偶发问题,日志比断点可靠。给几条判断标准,遇到新需求可以直接套:互不依赖、失败可降级,就并发;缺一个就不能继续,用 all 并准备好整页错误;只是「尽量都拿到」,用 allSettled 并统计失败数;一次要发超过 20 个请求,限流到 4 到 6;有写操作,串行并想清楚失败之后怎么收尾;轮询间隔小于上一轮平均耗时的两倍,就别用固定间隔。
小结
then 返回新 Promise,返回值决定下一步收到什么。catch;finally 无论成败都执行,适合关闭 loading。别写空的 catch。async/await 是 Promise 的写法升级,函数仍返回 Promise;try/catch 只接住 await 的错误。all,允许部分失败用 allSettled,超时用 race。今天可以自己验的几件事,不用等项目排期:
- 把任意一个接口地址改成不存在的路径,确认
res.ok是false而不是自动 reject,然后补上if (!res.ok) throw。 - 用
console.time包住三个独立请求,分别跑串行await和Promise.all,把两个耗时记下来,差值应该接近「最慢那个请求」。 - 故意让其中一个接口返回 500,检查页面其它区块是否还在、loading 是否关闭、失败那块有没有重试入口。
- 写一个
getJSON(url, ms),用AbortController做超时,把ms设成 300,请求一个慢接口,确认 catch 到的是AbortError而不是TypeError。 - 在
list.forEach(async ...)里await,打印每条的结束顺序,再换成for...of和Promise.all,对比总耗时和输出顺序。
下一篇讲错误处理与排查,建议紧接着读,别隔太久。原因很直接:这篇解决「怎么等、怎么并发」,而线上真正让人加班的是「错误没接住、接住了不知道怎么办」。下一篇会把错误对象、异步错误的漏点、排查顺序讲透,正好补上这篇反复提到的 catch 那一半;读完再回头看第 10 节的分块降级,会更容易想清楚每一块失败时页面该显示什么。