话说回来，

前言

Promise 源码看了一百遍。不如自己写一遍，

相信很多前端同学都有过这样的经历：面试问手写 Promise，网上搜一搜 "Promise A+ 规范实现"，接下来对着代码 Copy 一遍。写完还是云里雾里 —— 那些 .nPromise.resolvePromise.all 到底是怎么串起来的？

这篇文章不打算贴完整代码。而是换个方式：用一个最小、最简、最裸的 MiniPromise，带你从零理解 Promise 的设计思路。

. 先想清楚：Promise 解决什么问题？

在 Promise 出现之前，我们用回调函数来处理异步：

fetchData {
processResult {
saveData {
// ... 回调地狱
});})，});

这叫 回调地狱问题不仅仅是嵌套难读，错误处理分散、状态不可控。

Promise 的主要思路就两点：

1. 状态机pending → fulfilled / rejected。只能变一次
2. 链式调用.n 返回一个新的 Promise，实现"异步组合"

理解这两点，你就能自己动手写一个简化版 Promise。其实，

. MiniPromise 的主要结构

class MiniPromise {
constructor {
this.state = 'pending';不过，this.value = undefined;this.onFulfilledCallbacks =;this.onRejectedCallbacks =;const resolve = => this._resolve;const reject = => this._reject;try {
executor;} catch {
reject;}
}}

就这？一个类，三个属性，两个数组？

对，就是这么裸。按理说，Promise 本质就是一个状态容器所有的魔法都在 _resolve 方法里。

. 主要原因：状态流转 + 异步执行

_resolve {
// 只能从 pending 变一次
if return;// 如果 value 是 Promise。需要"展开"
if {
return value.n,this._reject.bind);}
this.state = 'fulfilled';this.value = value;// 异步执行回调 —— 这就是 n 可以链式调用的关键
queueMicrotask => {
this.onFulfilledCallbacks.forEach);})，}

等等，这里有个关键点：为什么要用 queueMicrotask？话说回来，

因为 Promise 的设计原则是：n 的回调必须异步执行。这保证了执行顺序的可预测性，也是 Promise/A+ 规范的要求。

. n 是怎么实现的？其实，

n {
// 返回一个新的 Promise。这就是链式调用的秘密
return new MiniPromise => {
const handleCallback = => {
try {
// 如果没有传回调，直接透传 value
const result = callback?
callback : value;resolve，// 关键：resolve 的是回调的返回值
} catch {
reject;}
}，if {
// 异步执行，保持一致性
queueMicrotask => handleCallback);} else if {
queueMicrotask => handleCallback);} else {
// pending 状态，先把回调存起来
this.onFulfilledCallbacks.push => handleCallback);this.onRejectedCallbacks.push => handleCallback);}
})，}

看到没？n 返回的是全新的 Promise,而不是直接返回结果。这个新 Promise 的 resolve 取决于回调函数的返回值——这就是链式调用的本质。

. 静态方法：Promise.resolve / Promise.reject

static resolve {
if return value;return new MiniPromise);}
static reject {
return new MiniPromise => reject);}

简单到不用解释。

. Promise.all 怎么写？

static all {
return new MiniPromise => {
const results =;let completed =;if return resolve;promises.forEach => {
MiniPromise.resolve.n(val => {
results = val;completed++，if resolve;},reject)，});})，说起来，}

至于主要就一个。遍历 +计数 +全部成功才 resolve.

. 写完 MiniPromise，我学到了什么？

1. 从魔法来看。: 就是一个有状态管理的异步容器，外加一套回调收集 + 异步调度机制。

2. 链式调用的本质：: 每个 .n` 返回一个新 Promise，上一个 n 的返回值成为下一个 n 的输入。其实，

3. `queueMicrotask` 的作用：: 确保 n 的回调总是异步执行。这是 Promise 行为一致性的根基。老实说，

4. `Promise.resolve` 的“递归展开”：: 如果 resolve 的是一个 Promise。需要等它完成后再 fulfill 当前 Promise，这是最难理解的部分。

手写一遍之后再看 Ppromise.all。Ppromise.race,,you 会发现它们都是建立在同一套机制上的延伸。

S源码不是魔法，原理才是。