罗罗编程学习记录
本页内容 展开查看

03.2.2.2 Promise 与 async/await

所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.2 JavaScript / 03.2.2 异步模型与浏览器运行时

03.2.2.2-001 Promise 有哪三种状态?状态转换有什么规则?

一句话结论

Promise 有 pending(进行中)、fulfilled(已成功)、rejected(已失败)三种状态;状态只能从 pending 转为 fulfilled 或 rejected 一次,之后不可逆,后续重复落定被忽略。

概念解释

  • pending:初始状态。
  • fulfilled:resolve(value) 落定。
  • rejected:reject(reason) 落定。
  • 不可逆:一次落定后不能再改状态。

原理流程

  1. 新建 Promise 处于 pending。
  2. 执行器内调用 resolve/reject 落定。
  3. 状态固定,回调按最终状态执行。

代码 / 示例

const p = new Promise((resolve, reject) => {
  resolve("ok");
  reject("err"); // 被忽略,状态已固定
});
p.then(v => console.log(v)); // "ok"

常见误区

  • 误区:resolve 后还能再 reject;正解:状态不可逆,第二次落定忽略。
  • 误区:reject 会同步抛错;正解:拒绝结果走 rejected 回调/微任务链,不冒泡为同步异常。

追问

  • Q:落定值可以是另一个 Promise 吗? A:可以,会跟随该 Promise 落定状态。
  • Q:状态在哪里观察? A:Promise.prototype.then/catch,内部状态不可直接读取。

03.2.2.2-002 Promise 链式调用中返回值如何被包装?

一句话结论

then 回调返回普通值,链上 Promise 以该值 fulfill;返回 Promise/thenable,链跟随其落定;回调抛错则后续链进入 rejected;链式每一环都返回新 Promise。

概念解释

  • 值穿透:返回非 Promise 值自动包装。
  • 跟随:返回 thenable 时采用其状态。
  • 每环独立新 Promise,不改变原 Promise。

原理流程

  1. 上一环落定触发 then 回调。
  2. 回调返回值/抛出错误。
  3. 包装为新 Promise 传给下一环。

代码 / 示例

Promise.resolve(1)
  .then(v => v + 1)          // 返回 2,包装为 fulfilled(2)
  .then(v => Promise.resolve(v + 1)) // 返回 Promise,跟随落定
  .then(v => console.log(v)); // 3

常见误区

  • 误区:then 回调直接修改原 Promise;正解:返回新 Promise 链。
  • 误区:返回字符串会被当作 Promise;正解:普通值自动包装为已落定 Promise。

追问

  • Q:回调返回 undefined 链会中断吗? A:不会,链以 undefined 继续。
  • Q:链式 catch 后能继续 then 吗? A:可以,catch 返回的值会让后续链恢复 fulfilled。

03.2.2.2-003 then、catch、finally 各自行为是什么?

一句话结论

then 接收成功/失败回调;catch 等价于 then(null, onRejected),捕获链上拒绝;finally 无论落定状态都执行,且默认透传上一环落定值,不接收参数。

概念解释

  • then:onFulfilled/onRejected 可选。
  • catch:错误处理落点。
  • finally:清理逻辑,不改变链状态(除非内部抛错)。

原理流程

  1. Promise 落定。
  2. 按状态进入对应回调。
  3. finally 执行后继续传递原值。

代码 / 示例

fetchData()
  .then(data => render(data))
  .catch(err => console.error(err))
  .finally(() => hideLoading());

常见误区

  • 误区:finally 能拿到落定值;正解:回调无参数,需在外层变量保存。
  • 误区:finally 抛错会被原链忽略;正解:finally 内抛错会成为新的 rejected 原因。

追问

  • Q:catch 之后再 then 是成功还是失败链? A:catch 正常返回值则后续为 fulfilled。
  • Q:finally 与 then 第二参数区别? A:finally 不区分状态都执行,catch 只处理拒绝。

03.2.2.2-004 all、allSettled、race、any 有什么区别?

一句话结论

all 全部成功才成功,任一失败即失败;allSettled 等待全部落定并返回各自状态;race 取最先落定(无论成败);any 取最先成功,全部失败才聚合失败。

概念解释

  • all:成功值数组,失败原因即首个拒绝。
  • allSettled:返回 {status, value/reason}。
  • race:首个落定决定结果。
  • any:首个成功决定,全失败抛 AggregateError。

原理流程

  1. 输入 Promise 数组并行执行。
  2. 按组合规则监听落定。
  3. 满足条件后落定聚合结果。

代码 / 示例

await Promise.all([p1, p2]);
await Promise.allSettled([p1, p2]);
await Promise.race([timeout, request]);
await Promise.any([p1, p2]);

常见误区

  • 误区:race 只取最先成功;正解:首个落定(含失败)即决定。
  • 误区:any 与 race 相同;正解:any 忽略失败,等首个成功。

追问

  • Q:all 中一个失败会取消其他请求吗? A:不会取消已发出的 Promise 执行,只是聚合提前拒绝。
  • Q:allSettled 结果如何读取? A:遍历结果对象按 status 取 value 或 reason。

03.2.2.2-005 什么是 thenable?值穿透怎么理解?

一句话结论

thenable 是带有 then 方法的对象,Promise 链会把它当作 Promise 跟随其落定;值穿透指链上某环省略回调时,值沿链直接传到下一环。

概念解释

  • thenable:鸭子类型,有 then 即可被跟随。
  • 值穿透:then 缺省回调不阻断传值。
  • 非 Promise 返回值自动包装。

原理流程

  1. 链检测返回值是否 thenable。
  2. 是则调用其 then 跟随落定。
  3. 普通值/省略回调继续向下传递。

代码 / 示例

const thenable = { then(resolve) { resolve("thenable"); } };
Promise.resolve()
  .then(() => thenable)
  .then(v => console.log(v)); // "thenable"

Promise.resolve(1).then().then(v => console.log(v)); // 1,穿透

常见误区

  • 误区:只有真正的 Promise 能进入链;正解:thenable 即可被跟随。
  • 误区:省略 then 会阻断值;正解:值穿透到后续回调。

追问

  • Q:thenable 的 then 被调用几次? A:由 Promise 规范调用,复用同一 thenable 时注意其内部状态。
  • Q:为什么 await 接受 thenable? A:await 同样识别 thenable 并跟随。

03.2.2.2-006 async 函数返回值有什么规则?

一句话结论

async 函数总是返回 Promise:返回普通值包装为 fulfilled,返回 Promise 直接沿用,抛错则返回 rejected Promise;函数内 return 对应 resolve,throw 对应 reject。

概念解释

  • 恒返回 Promise,即使返回非 Promise。
  • 内部异常转为拒绝。
  • 调用方用 await/then 取值。

原理流程

  1. 调用 async 函数立即返回 Promise。
  2. 函数体执行,遇 await 暂停。
  3. 返回值/异常落定对应 Promise。

代码 / 示例

async function f() { return 1; }
f(); // Promise { 1 }

async function g() { throw new Error("x"); }
g().catch(e => console.error(e));

常见误区

  • 误区:async 函数直接返回原值;正解:始终包装为 Promise。
  • 误区:async 内 throw 同步抛给调用方;正解:转为 rejected Promise,需 catch/await。

追问

  • Q:async 函数没有 return 返回什么? A:fulfilled(undefined)。
  • Q:顶层能用 await 吗? A:ESM 模块顶层支持 await,普通脚本环境不支持。

03.2.2.2-007 await 如何暂停与恢复执行?

一句话结论

await 暂停当前 async 函数,等待右侧 Promise 落定;落定后恢复回调作为微任务执行后续代码,继续返回值或抛出拒绝原因。

概念解释

  • 暂停:不阻塞事件循环,其他任务继续。
  • 恢复:微任务调度。
  • 拒绝:未捕获则进入函数返回的 rejected Promise。

原理流程

  1. 求值右侧表达式(非 Promise 包装)。
  2. 挂起函数,等待落定。
  3. 落定后微任务恢复,取值继续执行。

代码 / 示例

async function main() {
  const user = await fetchUser();
  const posts = await fetchPosts(user.id);
  console.log(posts);
}

常见误区

  • 误区:await 阻塞整个线程;正解:只暂停当前函数,事件循环继续。
  • 误区:await 多个请求天然并行;正解:按书写顺序串行等待,需并行先发起。

追问

  • Q:await 一个 reject 不捕获会怎样? A:函数返回的 Promise 拒绝,未处理则产生未处理拒绝告警。
  • Q:await 后代码属于宏任务还是微任务? A:微任务,见 03.2.2.1-007。

03.2.2.2-008 async/await 中如何处理错误?

一句话结论

用 try/catch/finally 包裹 await 捕获拒绝;catch 内可重新抛出或兜底返回;未捕获的拒绝沿返回 Promise 向上传播,必须在链尾处理,否则产生未处理拒绝。

概念解释

  • try:执行可能失败的 await。
  • catch:拿到拒绝原因。
  • finally:清理,不接收落定值。

原理流程

  1. await 拒绝进入 catch。
  2. catch 决定兜底或重抛。
  3. 未捕获向上传播为 rejected Promise。

代码 / 示例

async function load() {
  try {
    const data = await fetchData();
    return data;
  } catch (err) {
    console.error("加载失败", err);
    return fallback;
  } finally {
    hideLoading();
  }
}

常见误区

  • 误区:await 失败会被全局自动吞掉;正解:必须显式 catch,否则向上传播。
  • 误区:catch 只能 catch 第一个 await;正解:try 块内所有 await 拒绝都进入同一 catch。

追问

  • Q:多个独立请求如何分别兜底? A:分别 try/catch 或用 Promise.allSettled。
  • Q:catch 后再 throw 是什么行为? A:重新抛出,链继续 rejected。

03.2.2.2-009 串行与并行 Promise 怎么区分?

一句话结论

await Promise.all([p1, p2]) 先并行发起再聚合;在循环内逐个 await 是串行等待;要并行应先发起所有 Promise(数组 map),再统一等待聚合。

概念解释

  • 并行:Promise 同时开始执行,all 等待全部。
  • 串行:前一个落定才发起下一个。
  • 发起时机决定是否并行。

原理流程

  1. 并行:map 回调内创建并返回 Promise,同步阶段全部发起。
  2. all 等待聚合。
  3. 串行:循环内 await 后才进入下一轮。

代码 / 示例

// 并行
const [a, b] = await Promise.all([fetchA(), fetchB()]);

// 串行
for (const id of ids) {
  await fetchItem(id); // 逐个等待
}

// 并行批量
const results = await Promise.all(ids.map(id => fetchItem(id)));

常见误区

  • 误区:Promise.all 本身创建并行;正解:Promise 在创建时就开始执行,all 只聚合。
  • 误区:循环 map 后 await 是串行;正解:map 阶段已并行发起,await all 等待聚合。

追问

  • Q:请求间有依赖怎么办? A:先 await 前一个结果,再用结果发起后一个。
  • Q:并行请求过多怎么控制? A:并发池分批执行,见 03.2.2.2-010。

03.2.2.2-010 如何实现并发控制(并发池)?

一句话结论

并发池限制同时进行的 Promise 数量:维护运行计数与等待队列,任务完成后从队列取下一个,分批执行全部任务,避免一次性发起过多请求压垮服务或浏览器。

概念解释

  • 并发上限:同时执行的 Promise 数。
  • 队列:超额任务排队等待槽位。
  • 结果按原顺序收集。

原理流程

  1. 首批填充到并发上限。
  2. 任一完成取下一排队任务。
  3. 全部完成聚合结果。

代码 / 示例

async function pool(tasks, limit) {
  const results = new Array(tasks.length);
  let index = 0;
  const runners = Array.from({ length: Math.min(limit, tasks.length) }, async () => {
    while (index < tasks.length) {
      const i = index++;
      results[i] = await tasks[i]();
    }
  });
  await Promise.all(runners);
  return results;
}

常见误区

  • 误区:Promise.all 加 limit 参数即可;正解:all 无并发控制,需自实现池。
  • 误区:并发数越高越快;正解:受浏览器连接数、服务限流与内存约束,需压测确定。

追问

  • Q:结果顺序如何保证? A:按任务索引写入 results,不按完成先后覆盖。
  • Q:单个任务失败是否中断整体? A:按业务选择:all 提前失败,或 allSettled 收集失败。

03.2.2.2-011 如何用 race 实现超时控制?

一句话结论

Promise.race([请求, 超时Promise]) 先落定者决定结果;超时用 setTimeout 在指定时间后 reject,配合清除定时器避免泄漏。

概念解释

  • race 取首个落定。
  • 超时 Promise 到点拒绝。
  • 原请求不会被自动取消,需配合 AbortController。

原理流程

  1. 同时发起请求与超时定时器。
  2. 任一先落定,race 返回结果。
  3. 另一任务继续在后台,必要时取消。

代码 / 示例

function withTimeout(promise, ms) {
  const timeout = new Promise((_, reject) =>
    setTimeout(() => reject(new Error("timeout")), ms)
  );
  return Promise.race([promise, timeout]);
}

常见误区

  • 误区:race 超时后取消了原请求;正解:Promise 无法被取消,底层资源需 AbortController 终止。
  • 误区:超时定时器会自动清理;正解:请求先成功时应 clearTimeout。

追问

  • Q:超时后定时器回调还会执行吗? A:未清理则到点执行 reject,但 race 已忽略。
  • Q:浏览器原生超时方案? A:AbortSignal.timeout(ms) 生成超时信号(支持版本待确认)。

03.2.2.2-012 AbortController 如何取消 fetch?

一句话结论

AbortController 创建信号,fetch(url, { signal }) 监听;调用 controller.abort() 中止请求,fetch Promise 以 AbortError 拒绝;可复用于派生信号与超时组合。

概念解释

  • signal:可取消的信号对象。
  • abort:触发取消通知。
  • 取消原因:abort(reason) 传入拒绝原因。

原理流程

  1. 创建 controller 与 signal。
  2. fetch 传入 signal。
  3. 需要中止时调用 abort,请求中断并抛 AbortError。

代码 / 示例

const controller = new AbortController();
const signal = controller.signal;

fetch("/api", { signal })
  .catch(err => {
    if (err.name === "AbortError") console.log("已取消");
  });

controller.abort();

常见误区

  • 误区:Promise.race 超时等价于取消请求;正解:race 只放弃等待,网络请求仍在。
  • 误区:abort 后可以复用同一控制器再次请求;正解:信号已触发,需新建 controller。

追问

  • Q:如何组合超时与手动取消? A:AbortSignal.any([signal, AbortSignal.timeout(ms)])(支持版本待确认)。
  • Q:监听器如何监听取消? A:signal.addEventListener("abort", ...)。

03.2.2.2-013 手写 Promise 要覆盖哪些核心要点?

一句话结论

手写 Promise 要点:三状态常量、值/原因存储、then 回调队列订阅、落定时按状态执行、链式返回新 Promise、值穿透与 thenable 跟随、异步落定与错误透传。

概念解释

  • 状态机:pending/fulfilled/rejected。
  • 订阅:then 注册回调,落定时通知。
  • 链式:每环返回新 Promise 并处理返回值。

原理流程

  1. 构造器执行 executor,resolve/reject 改状态。
  2. then 注册成功/失败回调。
  3. 落定后微任务执行回调,包装返回值链向下一环。

代码 / 示例

class MyPromise {
  #state = "pending";
  #value;
  #onFulfilled = [];
  #onRejected = [];
  constructor(executor) {
    const resolve = (v) => this.#settle("fulfilled", v);
    const reject = (r) => this.#settle("rejected", r);
    executor(resolve, reject);
  }
  #settle(state, value) {
    if (this.#state !== "pending") return;
    this.#state = state;
    this.#value = value;
    (state === "fulfilled" ? this.#onFulfilled : this.#onRejected)
      .forEach(fn => fn(value));
  }
  then(onF, onR) { /* 链式返回新 Promise,处理返回值/thenable */ }
}

常见误区

  • 误区:then 回调同步执行;正解:规范要求落定回调进入微任务调度。
  • 误区:只存单个回调即可;正解:同一 Promise 可被多次 then,需队列订阅。

追问

  • Q:resolve 传入 Promise 如何跟随? A:需检查 thenable 并挂接其落定。
  • Q:catch/finally 如何在手写版实现? A:catch 是 then(null, fn),finally 执行后透传状态。

03.2.2.2-014 异步静默失败如何排查?

一句话结论

静默失败指 Promise 拒绝未被捕获,错误只在控制台告警或被吞掉;排查方向:检查链尾 catch、await 外层 try/catch、未注册回调的 Promise、异步回调内同步异常。

概念解释

  • 未捕获拒绝:无 catch 落点。
  • 回调内抛错:被 Promise 包裹为拒绝。
  • 日志缺失:错误未打印。

原理流程

  1. 定位未 await/未 then 的调用。
  2. 检查是否有 catch 兜底。
  3. 全局监听未处理拒绝补充日志。

代码 / 示例

window.addEventListener("unhandledrejection", (e) => {
  console.error("未处理拒绝", e.reason);
});

常见误区

  • 误区:函数内 catch 了就一定不会向外抛;正解:catch 中重抛仍向上传播。
  • 误区:setTimeout 回调内抛错会进入 Promise 链;正解:它是独立宏任务异常,与 Promise 链无关。

追问

  • Q:框架里的 async 事件处理器错误谁捕获? A:按框架错误边界/全局错误处理,需确认框架机制。
  • Q:fetch 404/500 算拒绝吗? A:不算,HTTP 错误状态仍 resolve,需检查 response.ok 后再抛错。

03.2.2.2-015 并发结果顺序如何保证?

一句话结论

Promise.all 按传入顺序返回结果数组,与完成先后无关;自行并发时用索引映射保存结果,避免按完成顺序覆盖导致错乱。

概念解释

  • all:结果顺序 = 输入顺序。
  • 完成顺序:受请求耗时影响不定。
  • 索引写入:自实现池按索引收集。

原理流程

  1. 并行发起任务并记录索引。
  2. 完成回调按索引写入结果槽。
  3. 全部落定后按索引返回数组。

代码 / 示例

const urls = ["/a", "/b", "/c"];
const results = await Promise.all(urls.map(u => fetch(u)));
// results[0] 对应 urls[0],不论谁先返回

常见误区

  • 误区:all 结果按完成先后排列;正解:按输入顺序排列。
  • 误区:forEach 并发收集数组可用 push;正解:push 顺序是完成顺序,需索引映射保持原序。

追问

  • Q:allSettled 结果顺序呢? A:同样按输入顺序。
  • Q:需要流式先到先展示怎么办? A:用任务完成回调逐条渲染,聚合顺序另用索引维护。

03.2.2.2-016 什么是 promisify?

一句话结论

promisify 把回调风格(error-first)的函数包装为返回 Promise 的函数:回调第一个参数为错误,第二个为结果,包装后 reject/resolve 对应。

概念解释

  • 回调风格:fn(arg, (err, data) => {})。
  • 包装:返回 Promise,回调内判断 err 落定。
  • Node 内置:util.promisify。

原理流程

  1. 调用原函数,传入包装回调。
  2. 回调收到 err/data。
  3. err 存在 reject,否则 resolve(data)。

代码 / 示例

function promisify(fn) {
  return (...args) => new Promise((resolve, reject) => {
    fn(...args, (err, data) => err ? reject(err) : resolve(data));
  });
}

常见误区

  • 误区:所有回调函数都能直接 promisify;正解:约定 error-first 双参数格式才可通用包装。
  • 误区:包装后原回调不再执行;正解:原函数行为不变,只是结果转 Promise。

追问

  • Q:回调传多个结果怎么处理? A:包装为对象/数组 resolve,或自定义适配。
  • Q:Node util.promisify 有特殊约定吗? A:支持 util.promisify.custom 符号自定义,按 Node 文档核实。

03.2.2.2-017 async 函数返回非 Promise 值时链上是什么状态?

一句话结论

async 函数返回普通值时,返回的 Promise 以该值 fulfilled;await 该值得到原值;返回 thenable 时跟随其状态;抛出错误则 rejected。

概念解释

  • 自动包装:非 Promise 值。
  • 跟随:thenable/Promise。
  • 异常:转拒绝。

原理流程

  1. async 函数体 return 表达式。
  2. 返回值经 Promise 包装/跟随。
  3. 调用方 await 取得最终值。

代码 / 示例

async function num() { return 42; }
num().then(v => v === 42); // true

async function wrapped() { return Promise.resolve("x"); }
await wrapped(); // "x"

常见误区

  • 误区:返回数字时 await 得到 Promise;正解:await 解包得到原值。
  • 误区:async 内 return undefined 会 reject;正解:fulfilled(undefined)。

追问

  • Q:async 函数内未 return 后续代码还执行吗? A:return 后函数结束,其后代码不执行。
  • Q:顶层 await 返回值给谁? A:模块顶层,无外层调用方,用于阻塞模块加载。

03.2.2.2-018 未处理的 Promise 拒绝会产生什么告警?

一句话结论

Promise 拒绝后没有任何 then 失败回调/catch 落点,浏览器与 Node 会报告未处理拒绝(unhandledrejection);早期静默吞掉,现代环境在控制台告警,部分 Node 版本可配置退出行为。

概念解释

  • 未处理:拒绝链上无 onRejected。
  • 告警事件:unhandledrejection。
  • 处理:链尾 catch 或全局监听兜底。

原理流程

  1. Promise 落定 rejected。
  2. 微任务阶段检查是否有拒绝处理器。
  3. 无处理器则触发未处理拒绝告警。

代码 / 示例

window.addEventListener("unhandledrejection", (event) => {
  console.error("未处理:", event.reason);
  event.preventDefault(); // 阻止默认控制台输出
});

常见误区

  • 误区:未捕获拒绝不会有任何提示;正解:现代环境会告警,调试信息不应依赖静默。
  • 误区:catch 注册晚于拒绝也能补救;正解:处理器需在链上注册,事后挂载不改变已发生的未处理判定。

追问

  • Q:Node 中未处理拒绝默认行为? A:历史版本演进为警告/退出行为,具体以目标 Node 版本为准(待确认)。
  • Q:如何统一兜底? A:全局监听 unhandledrejection 记录并上报,业务链上仍应显式处理。