一、为什么我们需要 Promise？—— 从“回调地狱”说起
在 JavaScript 的世界里，很多任务并不是“立刻就能完成”的。比如你想从服务器上获取一段用户信息，或者等两秒钟再弹出一个提示框，又或者读取本地的一个文件。这些操作都有一个共同特点：它们需要时间，而这个时间往往是不可预测的。如果程序傻傻地停下来等结果回来，整个页面就会卡住，用户什么都不能做——这显然不是我们想要的效果。
于是，JavaScript 采用了一种叫“异步”的方式来处理这类任务。它不会阻塞主线程，而是先发起请求，然后继续执行后面的代码，等到结果真正准备好了，再通过某种机制通知你。这种设计让网页始终保持响应，用户体验更流畅。
最早的时候，我们用“回调函数”来实现这种通知机制。比如 setTimeout，你可以传一个函数进去，告诉它：“等两秒后，再执行这个函数。” 这听起来很合理，但问题来了：如果多个异步操作需要按顺序执行，代码就会变成这样：
setTimeout(() => {
console.log("第一步完成");
setTimeout(() => {
console.log("第二步完成");
setTimeout(() => {
console.log("第三步完成");
}, 1000);
}, 1000);
}, 1000);
看起来还不算太乱？但如果换成加载用户信息、再根据用户信息加载订单、再加载订单详情、再加载推荐商品……每一层都依赖上一层的结果，代码就会层层嵌套，像一座金字塔一样向右延伸。这种结构被开发者们戏称为“回调地狱”（Callback Hell）。它不仅难读、难维护，而且一旦出错，调试起来也非常痛苦——你根本不知道是哪一层出了问题。
为了解决这个问题，ES6 引入了 Promise。它的出现，就像给异步编程带来了一束光。Promise 的核心思想是：我不再把下一步的操作写在回调里，而是返回一个“承诺对象”，你可以在这个对象上链式地注册成功或失败的处理函数。这样一来，原本层层嵌套的代码，就可以变成一条清晰的“流水线”，读起来就像是从上到下自然执行的同步代码。
二、Promise 到底是什么？
你可以把 Promise 想象成生活中的一种“承诺”。比如你答应朋友：“明天请你吃饭。” 这个承诺在当下并没有兑现，但它代表了一个未来的可能性。从你说出这句话开始，这个承诺就进入了某种“状态”：它可能是正在进行中（还没到明天），也可能是已经兑现了（你真的请了），也可能是失败了（你临时有事去不了）。
在 JavaScript 中，Promise 就是这样一个表示“未来结果”的对象。它并不立刻给出异步操作的结果，而是先给你一个“承诺”，告诉你这个操作正在进行中，等它完成了，你会收到通知。你可以通过这个 Promise 对象，提前注册好“如果成功了该怎么办”和“如果失败了又该怎么办”。
换句话说，Promise 是一个容器，里面装着一个将来才会完成的异步操作的结果。它让你可以用一种结构化、可预测的方式来处理异步逻辑，而不是像以前那样，把回调函数像“补丁”一样到处贴。
三、Promise 的三种状态
Promise 内部其实是一个非常简单的状态机，它只能处于三种状态之一：
第一种是 pending，也就是“进行中”。这是 Promise 的初始状态，表示异步操作还没有完成，结果还没出来。就像你刚答应请朋友吃饭，但还没到时间。
第二种是 fulfilled，意思是“已成功”。当异步操作顺利完成，Promise 就会从 pending 变成fulfilled，并且携带上操作的结果。比如你真的请朋友吃了饭，承诺兑现了。
第三种是 rejected，意思是“已失败”。如果异步操作出了问题，比如网络断了、文件找不到，Promise 就会进入 rejected 状态，并携带一个失败的原因。
这里最关键的一点是：状态的改变是单向且不可逆的。一旦一个 Promise 从 pending 变成了 fulfilled 或 rejected，它就永远不会再变了。你不能把一个已经成功的 Promise 变回进行中，也不能让它从失败变成成功。这种“一锤定音”的特性，保证了 Promise 的结果是可靠的，不会被后续的操作篡改。
四、如何创建一个 Promise？—— 从 new Promise 开始
要创建一个 Promise，我们需要使用 new Promise() 构造函数。它接收一个函数作为参数，这个函数被称为“执行器”（executor），它会在 Promise 被创建时立即执行。
这个执行器函数本身又接收两个参数：resolve 和 reject。它们都是函数，由 JavaScript 引擎自动提供。你可以把它们想象成“开关”：
- 当你调用
resolve(结果)时，就相当于告诉 Promise：“任务完成了，这是结果，请进入 fulfilled 状态。” - 当你调用
reject(原因)时，就表示：“任务失败了，这是失败的原因，请进入 rejected 状态。”
举个例子，我们可以用 Promise 来模拟一个延迟一秒钟后返回结果的操作：
const myPromise = new Promise((resolve, reject) => {
setTimeout(() => {
const success = Math.random() > 0.5; // 模拟随机成功或失败
if (success) {
resolve("操作成功！🎉");
} else {
reject("操作失败！😭");
}
}, 1000);
});
注意，这里的 setTimeout 是异步的，但 new Promise() 里面的代码是同步执行的。也就是说，当你写下 const myPromise = new Promise(...) 这一行时，里面的函数会立刻运行，只是它内部的 resolve 或 reject 会在一秒钟后才被调用。
五、如何使用 Promise？—— then、catch 和 finally 的协作
创建了 Promise 之后，我们怎么知道它是成功了还是失败了？这就需要用到 .then()、.catch() 和 .finally() 这三个方法。
1..then()
.then() 是最常用的，它用来注册成功后的处理逻辑。你可以给它传一个函数，当 Promise 进入 fulfilled 状态时，这个函数就会被调用，并接收到 resolve 传来的值。
2.catch()
.catch() 则是用来处理失败情况的。当 Promise 被 reject，或者在执行过程中抛出异常时，.catch() 里的回调就会被执行，它会接收到失败的原因。
3.finally()
而 .finally() 是一个很有意思的方法，它注册的函数无论成功还是失败都会执行。它不关心结果，只关心“这件事终于结束了”。这个方法非常适合用来做清理工作，比如关闭 loading 动画、释放资源等。因为它不接收任何参数，所以你无法从 .finally() 里知道到底是成功还是失败，它只是告诉你：“任务结束了。”
这三个方法组合起来，构成了一个完整的异步处理流程：
myPromise
.then(result => {
console.log("成功了！", result);
})
.catch(error => {
console.error("失败了！", error);
})
.finally(() => {
console.log("无论成功失败，我都会执行！");
});
这种写法清晰地表达了“如果成功就怎样，如果失败就怎样，最后不管怎样都要收尾”的逻辑，比层层嵌套的回调直观太多了。
六、链式调用的魅力 —— 让异步代码像流水线一样执行
Promise 最强大的特性之一就是链式调用。你可能注意到，每次调用 .then()，它都会返回一个全新的 Promise 对象。这意味着你可以在后面继续 .then()，形成一条长长的链条。
更重要的是，你在前一个 .then() 中 return 的值，会成为下一个 .then() 的参数。如果 return 的是一个 Promise，那么下一个 .then() 会等它完成后再执行。这就像是把多个异步任务串成一条流水线，一个接一个地执行。
比如，我们可以先发起一个网络请求获取用户信息，然后根据用户 ID 再请求他的订单列表，最后把订单数据显示出来：
fetch('/api/user')
.then(response => response.json())
.then(user => fetch(`/api/orders?userId=${user.id}`))
.then(response => response.json())
.then(orders => console.log(orders))
.catch(error => console.error('出错了：', error));
你看，整个流程从上到下，逻辑清晰，没有嵌套。每一个 .then() 都专注于处理上一步的结果，而错误处理只需要一个 .catch() 就能覆盖整条链。这就是 Promise 带来的革命性变化。
七、批量处理多个异步任务 —— Promise 的静态方法
有时候，我们不是只处理一个异步任务，而是要同时处理多个。比如页面要同时加载头像、昵称、个人简介三个接口，或者要上传多张图片。这时候，Promise 提供了几个非常实用的静态方法来帮我们管理这些“批量任务”。
Promise.all 是最常用的一个。它接收一个 Promise 数组，然后返回一个新的 Promise。这个新的 Promise 只有在所有子 Promise 都成功时才会成功，只要有一个失败，它就立刻失败。它的结果是一个数组，包含所有子 Promise 的结果，顺序和传入的数组一致。这非常适合“必须全部成功”的场景，比如表单验证、多资源预加载。
但有时候，我们并不希望因为一个失败就放弃全部。比如你提交了多个订单，哪怕其中几个失败了，你也想知道其他几个的结果。这时候 Promise.allSettled 就派上用场了。它会等所有 Promise 都结束（不管是成功还是失败），然后返回一个包含每个 Promise 状态和结果的数组。这样你就可以逐个分析每个任务的执行情况。
Promise.race 则走的是“速度优先”路线。它也接收一个 Promise 数组，但谁先结束（不管是成功还是失败），它就采用谁的结果。这个方法常用来实现“超时控制”。比如你发起一个网络请求，同时启动一个 5 秒的定时器，如果 5 秒内没拿到数据，就让定时器的 Promise 先“赢”，从而中断请求。
MyPromise.race = function (promises) {
// 第一步：返回一个新的 Promise
return new MyPromise((resolve, reject) => {
// 第二步：遍历每一个 promise
for (let promise of promises) {
// 把每个 promise 都包装成 MyPromise（兼容普通值）
MyPromise.resolve(promise)
.then((value) => {
// 只要有一个成功，立刻 resolve（赢了！）
resolve(value);
})
.catch((reason) => {
// 只要有一个失败，立刻 reject（也赢了！）
reject(reason);
});
}
});
};
还有一个比较新的方法叫 Promise.any，它和 race 类似，但更“乐观”。它只关心谁先成功，只要有一个 Promise 成功，它就成功；只有当所有 Promise 都失败时，它才会失败，并抛出一个 AggregateError。这在有多个备用数据源的场景下特别有用，比如同时从多个服务器拉取数据，哪个快用哪个。
八、面试常问：Promise 的底层机制
在面试中，关于 Promise 的问题往往不会停留在“怎么用”，而是会深入到“为什么这样设计”。比如，new Promise() 里的代码到底是同步还是异步执行的？
答案是：executor 函数是同步执行的。也就是说，当你写下 new Promise(...) 的那一刻，里面的代码就会立刻运行。但 .then() 里的回调函数是异步的，而且它属于“微任务”（microtask）。微任务的优先级比 setTimeout 这种“宏任务”高，所以它会在当前事件循环的末尾、下一次渲染之前执行。
举个例子：
console.log(1);
new Promise(resolve => {
console.log(2);
resolve();
}).then(() => console.log(4));
console.log(3);
这段代码的输出是 1 → 2 → 3 → 4。因为 new Promise 里的 console.log(2) 是同步执行的，而 .then() 的回调会被放入微任务队列，等到同步代码执行完后再执行。
另一个常见问题是：async/await 和 Promise 是什么关系？其实 async/await 就是 Promise 的语法糖。async 函数会自动返回一个 Promise，而 await 关键字会“暂停”函数的执行，等待后面的 Promise 完成后再继续。它让异步代码看起来像是同步的，大大提升了可读性。
九、一些实用的小技巧
在实际开发中，还有一些小技巧能让 Promise 用得更顺手。比如 Promise.resolve(value) 可以快速创建一个已经成功的 Promise，Promise.reject(reason) 则创建一个已经失败的。这在封装 API 或模拟数据时特别方便。
还有一个技巧是：在 .then() 中返回一个新的 Promise，可以实现异步操作的串行执行。比如你可以写一个 delay 函数，返回一个延迟指定时间后 resolve 的 Promise，然后把它用在链式调用中，精确控制每一步的执行时机。
