一个首页要同时拉用户信息、订单列表、公告三条数据。为了快,用了 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;有写操作,串行并想清楚失败之后怎么收尾;轮询间隔小于上一轮平均耗时的两倍,就别用固定间隔。

小结

Promise 只有 pending、fulfilled、rejected 三态,且只变一次;then 返回新 Promise,返回值决定下一步收到什么。
错误沿链找最近的 catch;finally 无论成败都执行,适合关闭 loading。别写空的 catch。
async/await 是 Promise 的写法升级,函数仍返回 Promise;try/catch 只接住 await 的错误。
互不依赖的请求用并发;缺一不可用 all,允许部分失败用 allSettled,超时用 race。

今天可以自己验的几件事,不用等项目排期:

  1. 把任意一个接口地址改成不存在的路径,确认 res.ok 是 false 而不是自动 reject,然后补上 if (!res.ok) throw。
  2. 用 console.time 包住三个独立请求,分别跑串行 await 和 Promise.all,把两个耗时记下来,差值应该接近「最慢那个请求」。
  3. 故意让其中一个接口返回 500,检查页面其它区块是否还在、loading 是否关闭、失败那块有没有重试入口。
  4. 写一个 getJSON(url, ms),用 AbortController 做超时,把 ms 设成 300,请求一个慢接口,确认 catch 到的是 AbortError 而不是 TypeError。
  5. 在 list.forEach(async ...) 里 await,打印每条的结束顺序,再换成 for...of 和 Promise.all,对比总耗时和输出顺序。

下一篇讲错误处理与排查,建议紧接着读,别隔太久。原因很直接:这篇解决「怎么等、怎么并发」,而线上真正让人加班的是「错误没接住、接住了不知道怎么办」。下一篇会把错误对象、异步错误的漏点、排查顺序讲透,正好补上这篇反复提到的 catch 那一半;读完再回头看第 10 节的分块降级,会更容易想清楚每一块失败时页面该显示什么。