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 方法的对象/函数,需要递归解析。
原理流程
- 构造 Promise 时立即调用
executor(resolve, reject)。 - resolve/reject 仅在 pending 时生效,改变状态并保存值。
- 状态已变则同步调度回调;否则把回调推入队列。
- 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 实例,但行为类似。
原理流程
- 状态校验:仅 pending 可迁移。
- thenable 递归:每次取出 then 方法,用 call 绑定 this。
- 防止循环:若 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。
原理流程
- all:计数器记录已完成数量,全部完成后 resolve。
- race:第一个 then 触发即 resolve/reject。
- allSettled:无论成败都记录,最后统一 resolve。
- 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,在当前宏任务结束后立即清空。
原理流程
- 同步代码执行完。
- 清空微任务队列。
- 浏览器渲染(可选)。
- 取下一个宏任务。
代码 / 示例
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 时,错误一直传播。
原理流程
- then 内部判断回调是否函数。
- 非函数替换为恒等函数或抛错函数。
代码 / 示例
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 => ...)。
原理流程
- 微任务清空后检查是否有未处理的 reject。
- 若有则触发事件,默认行为是打印到控制台。
代码 / 示例
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。
- 队列:先进先出。
原理流程
- 初始并发数内立即启动任务。
- 任务完成后从队列取下一个。
- 全部完成后 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 抛出的错误。
原理流程
- await 后面是 Promise 时,函数暂停。
- Promise reject 时,等价于 throw。
- 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 风格