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

03.10.3 Promise 原理与 A+ 实现

所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.10 前端手写实现

覆盖范围

  • 状态机:pending / fulfilled / rejected,状态单向流转
  • then 与链式:回调队列、thenable 识别、值穿透
  • 微任务调度:MutationObserver / queueMicrotask / process.nextTick
  • 静态方法:all / race / allSettled / any / resolve / reject
  • 错误冒泡与 catch:unhandledrejection

高频题速览

编号 题目 难度 频率
03.10.3-001 实现符合 A+ 规范的 Promise 高级 ★★★★★
03.10.3-002 Promise 状态机与 thenable 解析 进阶 ★★★★★
03.10.3-003 手写 Promise.all / race / allSettled / any 进阶 ★★★★★
03.10.3-004 then 为什么是微任务 进阶 ★★★★
03.10.3-005 值穿透与 then 传非函数 进阶 ★★★★
03.10.3-006 unhandledrejection 如何产生 进阶 ★★★
03.10.3-007 手写 Promise 并发限流 高级 ★★★★
03.10.3-008 Promise 与 async/await 的错误处理差异 基础 ★★★★

03.10.3-001 实现符合 A+ 规范的 Promise

一句话结论

Promise 是一个带三种状态的有限状态机:构造时 executor 立即执行,resolve/reject 改变状态并触发回调队列;then 返回新 Promise,回调通过微任务异步调度,处理返回值时递归解析 thenable。

概念解释

  • 状态:pending → fulfilled 或 rejected,不可逆。
  • 回调队列:状态未变时收集 onFulfilled/onRejected,状态变后按序执行。
  • thenable:具有 then 方法的对象/函数,需要递归解析。

原理流程

  1. 构造 Promise 时立即调用 executor(resolve, reject)。
  2. resolve/reject 仅在 pending 时生效,改变状态并保存值。
  3. 状态已变则同步调度回调;否则把回调推入队列。
  4. then 返回新 Promise,回调结果通过 resolvePromise 解析。

代码 / 示例

const PENDING = "pending";
const FULFILLED = "fulfilled";
const REJECTED = "rejected";

class MyPromise {
  constructor(executor) {
    this.state = PENDING;
    this.value = undefined;
    this.reason = undefined;
    this.onFulfilledCbs = [];
    this.onRejectedCbs = [];

    const resolve = (value) => {
      if (value instanceof MyPromise) {
        return value.then(resolve, reject);
      }
      if (this.state !== PENDING) return;
      this.state = FULFILLED;
      this.value = value;
      this.onFulfilledCbs.forEach((cb) => cb(value));
    };
    const reject = (reason) => {
      if (this.state !== PENDING) return;
      this.state = REJECTED;
      this.reason = reason;
      this.onRejectedCbs.forEach((cb) => cb(reason));
    };

    try {
      executor(resolve, reject);
    } catch (e) {
      reject(e);
    }
  }

  then(onFulfilled, onRejected) {
    onFulfilled = typeof onFulfilled === "function" ? onFulfilled : (v) => v;
    onRejected =
      typeof onRejected === "function"
        ? onRejected
        : (e) => {
            throw e;
          };
    const p2 = new MyPromise((resolve, reject) => {
      const handleFulfilled = () =>
        queueMicrotask(() => {
          try {
            const x = onFulfilled(this.value);
            resolvePromise(p2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        });
      const handleRejected = () =>
        queueMicrotask(() => {
          try {
            const x = onRejected(this.reason);
            resolvePromise(p2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        });
      if (this.state === FULFILLED) handleFulfilled();
      else if (this.state === REJECTED) handleRejected();
      else {
        this.onFulfilledCbs.push(handleFulfilled);
        this.onRejectedCbs.push(handleRejected);
      }
    });
    return p2;
  }

  catch(onRejected) {
    return this.then(null, onRejected);
  }
}

function resolvePromise(p2, x, resolve, reject) {
  if (p2 === x) return reject(new TypeError("Chaining cycle detected"));
  if (x && typeof x === "object") || typeof x === "function") {
    let then;
    try {
      then = x.then;
    } catch (e) {
      return reject(e);
    }
    if (typeof then === "function") {
      let called = false;
      try {
        then.call(
          x,
          (y) => {
            if (called) return;
            called = true;
            resolvePromise(p2, y, resolve, reject);
          },
          (r) => {
            if (called) return;
            called = true;
            reject(r);
          }
        );
      } catch (e) {
        if (called) return;
        reject(e);
      }
    } else {
      resolve(x);
    }
  } else {
    resolve(x);
  }
}

常见误区

  • 误区:回调在 then 时同步执行;正解:即使 Promise 已 fulfilled,then 回调也必须进入微任务队列,保证异步语义一致。
  • 误区:resolvePromise 中 x 是 Promise 就直接 resolve;正解:需要处理 thenable 与循环引用,否则不符合 A+ 规范。

追问

  • Q:如何验证 A+ 合规? A:使用 promises-aplus-tests 跑测试套件。
  • Q:为什么 resolvePromise 要 called 标志? A:thenable 可能同时调用成功与失败回调,规范要求只认第一次。

03.10.3-002 Promise 状态机与 thenable 解析

一句话结论

Promise 状态只能从 pending 转到 fulfilled 或 rejected,且不可逆;thenable 是任意具有 then 方法的对象,Promise 解析时会递归调用其 then,直到得到非 thenable 值。

概念解释

  • 不可逆:一旦 settled,再次 resolve/reject 无效。
  • thenable:不一定是 Promise 实例,但行为类似。

原理流程

  1. 状态校验:仅 pending 可迁移。
  2. thenable 递归:每次取出 then 方法,用 call 绑定 this。
  3. 防止循环:若 x 与 p2 相同则抛 TypeError。

代码 / 示例

Promise.resolve({
  then(resolve) {
    resolve(42);
  },
}).then(console.log); // 42

常见误区

  • 误区:Promise.resolve(p) 返回同一个 Promise;正解:是的,规范规定若传入 Promise 则原样返回。
  • 误区:thenable 与 Promise 等价;正解:thenable 不一定有 catch/static 方法,await 只认 thenable 形态。

追问

  • Q:为什么 await 能等待 thenable? A:await 内部就是把值转成 Promise,thenable 会被递归解析。
  • Q:递归 thenable 有什么风险? A:深层嵌套 thenable 可能栈溢出,需要 trampoline 或迭代实现(现代引擎做了优化)。

03.10.3-003 手写 Promise.all / race / allSettled / any

一句话结论

all 等待全部成功,任一失败即失败;race 取第一个落定;allSettled 等待全部落定并返回状态对象;any 等待第一个成功,全部失败才抛 AggregateError。

概念解释

  • all:成功返回数组,失败即 reject。
  • race:取最先 settled 的结果。
  • allSettled:返回 {status, value/reason}。
  • any:全部 reject 时抛 AggregateError。

原理流程

  1. all:计数器记录已完成数量,全部完成后 resolve。
  2. race:第一个 then 触发即 resolve/reject。
  3. allSettled:无论成败都记录,最后统一 resolve。
  4. any:失败计数,全部失败时抛 AggregateError。

代码 / 示例

MyPromise.all = function (iterable) {
  const arr = Array.from(iterable);
  return new MyPromise((resolve, reject) => {
    if (arr.length === 0) return resolve([]);
    const result = [];
    let count = 0;
    arr.forEach((p, i) => {
      MyPromise.resolve(p).then(
        (v) => {
          result[i] = v;
          if (++count === arr.length) resolve(result);
        },
        reject
      );
    });
  });
};

MyPromise.race = function (iterable) {
  return new MyPromise((resolve, reject) => {
    Array.from(iterable).forEach((p) =>
      MyPromise.resolve(p).then(resolve, reject)
    );
  });
};

MyPromise.allSettled = function (iterable) {
  return MyPromise.all(
    Array.from(iterable).map((p) =>
      MyPromise.resolve(p).then(
        (value) => ({ status: "fulfilled", value }),
        (reason) => ({ status: "rejected", reason })
      )
    )
  );
};

MyPromise.any = function (iterable) {
  return new MyPromise((resolve, reject) => {
    const arr = Array.from(iterable);
    const errors = [];
    let count = 0;
    arr.forEach((p, i) => {
      MyPromise.resolve(p).then(
        resolve,
        (e) => {
          errors[i] = e;
          if (++count === arr.length) reject(new AggregateError(errors, "All rejected"));
        }
      );
    });
  });
};

常见误区

  • 误区:all 传入空数组立即 resolve;正解:是的,返回空数组。
  • 误区:any 全部失败返回 undefined;正解:规范要求抛 AggregateError(ES2021)。

追问

  • Q:race 与 setTimeout 配合? A:Promise.race([fetch(url), timeout(5000)]) 实现超时。
  • Q:allSettled 用 all 实现有什么问题? A:上面实现是对的,因为 all 内部每个 promise 都被 then 包成永远 resolve。

03.10.3-004 then 为什么是微任务

一句话结论

Promise/A+ 规范要求 then 回调在当前事件循环结束后、下一轮宏任务之前执行,因此走微任务队列(Node 用 process.nextTick + PromiseJobs,浏览器用 MutationObserver 后 queueMicrotask),保证同步代码先执行。

概念解释

  • 宏任务:setTimeout、I/O、UI 事件。
  • 微任务:Promise then、queueMicrotask、MutationObserver,在当前宏任务结束后立即清空。

原理流程

  1. 同步代码执行完。
  2. 清空微任务队列。
  3. 浏览器渲染(可选)。
  4. 取下一个宏任务。

代码 / 示例

console.log(1);
Promise.resolve().then(() => console.log(2));
setTimeout(() => console.log(3));
console.log(4);
// 1 4 2 3

常见误区

  • 误区:setTimeout(0) 比 Promise.then 早;正解:setTimeout 是宏任务,Promise 是微任务。
  • 误区:queueMicrotask 与 Promise.then 顺序随机;正解:按入队顺序执行。

追问

  • Q:Node 中 process.nextTick 与 Promise.then 谁先? A:nextTick 先于 Promise 微任务。
  • Q:微任务过长会怎样? A:阻塞渲染,应拆分到宏任务(setTimeout/setImmediate)。

03.10.3-005 值穿透与 then 传非函数

一句话结论

then 若传入非函数值,会被忽略并把上一层的值透传到下一层;错误未处理时会冒泡到链上第一个 onRejected。

概念解释

  • 值穿透:p.then(1).then(console.log) 等价于 p.then(v => v).then(console.log)。
  • 错误冒泡:链上没有 onRejected 时,错误一直传播。

原理流程

  1. then 内部判断回调是否函数。
  2. 非函数替换为恒等函数或抛错函数。

代码 / 示例

Promise.resolve(42)
  .then(null)
  .then((v) => console.log(v)); // 42

常见误区

  • 误区:传 null 会报错;正解:then 会忽略并继续穿透。
  • 误区:catch 后链断了;正解:catch 返回新 Promise,链继续。

追问

  • Q:为什么这样设计? A:让 .then(fn).catch(h) 与 .then(fn, h) 在链上更灵活。
  • Q:then 第二个参数与 catch 有什么区别? A:then 的 onRejected 只能捕获前一个 Promise 的错误,catch 捕获整条链。

03.10.3-006 unhandledrejection 如何产生

一句话结论

Promise 被 reject 后,如果整条链没有任何 onRejected/catch 处理器,浏览器触发 unhandledrejection 事件,Node 触发 unhandledRejection 警告。

概念解释

  • 未处理拒绝:rejected 状态没有 catch。
  • 事件:window.addEventListener("unhandledrejection", e => ...)。

原理流程

  1. 微任务清空后检查是否有未处理的 reject。
  2. 若有则触发事件,默认行为是打印到控制台。

代码 / 示例

window.addEventListener("unhandledrejection", (e) => {
  console.error(e.reason);
  e.preventDefault();
});
Promise.reject(new Error("boom"));

常见误区

  • 误区:catch 写在链尾就一定被触发;正解:若 catch 前的 Promise 已 settled 且未注册处理器,事件仍会触发(浏览器在微任务结束时检查)。
  • 误区:unhandledrejection 可阻止默认控制台输出;正解:调用 e.preventDefault()。

追问

  • Q:为什么 Vue/React 团队重视它? A:未捕获 Promise 错误常导致接口失败无感知。
  • Q:Node 中行为? A:未来版本会默认抛异常退出,必须显式处理。

03.10.3-007 手写 Promise 并发限流

一句话结论

并发限流固定同时运行的 Promise 数量,队列维护待执行任务,每个任务完成后从队列取下一个。

概念解释

  • 并发数:maxConcurrency。
  • 队列:先进先出。

原理流程

  1. 初始并发数内立即启动任务。
  2. 任务完成后从队列取下一个。
  3. 全部完成后 resolve 结果数组。

代码 / 示例

function poolLimit(tasks, limit) {
  const results = [];
  let i = 0;
  function next() {
    if (i >= tasks.length) return Promise.resolve();
    const idx = i++;
    return tasks[idx]().then((v) => {
      results[idx] = v;
      return next();
    });
  }
  const runners = Array.from({ length: Math.min(limit, tasks.length) }, next);
  return Promise.all(runners).then(() => results);
}

常见误区

  • 误区:用 Promise.all 包所有任务就有限流;正解:all 会立即启动所有任务,没有并发控制。
  • 误区:失败即终止;正解:根据业务需要决定是否 catch 后继续或终止。

追问

  • Q:如何实现带超时的限流? A:每个任务包一层 Promise.race 超时。
  • Q:浏览器请求并发限制? A:同源 HTTP/1.1 有 6 个连接限制,并发过多反而排队。

03.10.3-008 Promise 与 async/await 的错误处理差异

一句话结论

async/await 用 try/catch 捕获错误,本质是 Promise.then 的语法糖;未捕获的 await 错误会让 async 函数返回 rejected Promise。

概念解释

  • await:暂停函数执行,等待 Promise 落定。
  • try/catch:捕获同步与 await 抛出的错误。

原理流程

  1. await 后面是 Promise 时,函数暂停。
  2. Promise reject 时,等价于 throw。
  3. try/catch 捕获。

代码 / 示例

async function fetchUser() {
  try {
    const res = await fetch("/api/user");
    return res.json();
  } catch (e) {
    console.error(e);
  }
}

常见误区

  • 误区:await 能捕获同步 throw;正解:是的,因为 await 把函数变成异步执行。
  • 误区:多个 await 串行执行性能差;正解:应在不依赖时用 Promise.all 并行。

追问

  • Q:async 函数返回值是什么? A:一定是 Promise,即使 return 一个普通值。
  • Q:顶层 await 可用吗? A:ESM 模块顶层可用,CJS 不可用。

待整理清单

  • [ ] Promise 取消与 AbortController 集成
  • [ ] Promise 进度通知(progress)实现
  • [ ] 手写 deferred 与 jquery 风格