Promise 是 JavaScript 中用于表示一个异步操作最终完成(或失败)及其结果值的对象。
它的出现只有一个核心目的:把异步操作的"结果"当作一个值来传递和处理,从而解决传统回调函数嵌套带来的回调地狱(Callback Hell)问题。
回调地狱的典型形态:每一步异步都依赖上一步的结果,代码不断向右/向内缩进,错误处理被重复书写无数遍,根本无法维护。
// ❌ 回调地狱:层层嵌套,错误各自处理,难以阅读与复用
fs.readFile("./a.txt", "utf-8", (err, data1) => {
if (err) throw err;
fs.readFile("./b.txt", "utf-8", (err, data2) => {
if (err) throw err;
fs.readFile("./c.txt", "utf-8", (err, data3) => {
if (err) throw err;
console.log(data1 + data2 + data3);
});
});
});
// ✅ Promise + async/await:扁平化书写,错误一处统一处理
async function main() {
const data1 = await mineReadFile("./a.txt");
const data2 = await mineReadFile("./b.txt");
const data3 = await mineReadFile("./c.txt");
console.log(data1 + data2 + data3);
}
main().catch(console.error);
ECMAScript 2015 (ES6)
1. 为什么需要 Promise
在没有 Promise 之前,异步操作只能通过回调函数完成:把”接下来要做的事”作为参数传给异步 API,由它在合适的时机回调。
这种方式有几个致命缺陷:
| 缺陷 | 说明 |
|---|---|
| 回调地狱 | 多个异步存在前后依赖时层层嵌套,代码横向膨胀,可读性极差 |
| 错误处理重复 | 每一层都要写一遍 if (err),稍有遗漏就会静默失败 |
| 控制流孱弱 | 想实现”全部完成”、”谁先完成”这类并发控制,需要手写计数器,极易出错 |
| 信任问题 | 回调可能被调用 0 次、1 次、甚至多次,被调用的时机也不受控 |
| 无法返回值 | 异步函数里 return 拿不到结果,只能层层往外传回调 |
Promise 把这些痛点一次性解决:它用一个对象代理未来才会拿到的结果,让你可以链式调用、统一捕获错误、自由组合并发。
2. Promise 的三种状态
Promise 实例内部维护一个状态(PromiseState),它只有三种取值。
状态不可逆,且只能改变一次
一个 Promise 一旦从 pending 变为 fulfilled 或 rejected,就永远不会再变:
- 不能从
fulfilled变回pending - 不能从
rejected变成pending或fulfilled
因此下面的代码中,第二行的 reject 和第三行的 throw 都完全无效——第一行执行完,状态就已经落定了。
let p = new Promise((resolve, reject) => {
resolve("ok"); // pending => fulfilled
reject("error"); // ❌ 无效,状态已锁定
throw "error"; // ❌ 无效,状态已锁定
});
console.log(p); // Promise {<fulfilled>: "ok"}
3. Promise 的基本使用
3.1 创建 Promise
Promise 是一个构造函数,接收一个执行器函数(executor)作为参数。
执行器是同步立即执行的
new Promise(fn) 时,fn 会被立刻同步调用,它内部的 console.log 会排在后续同步代码之前。
// 执行器立即执行
let p = new Promise((resolve, reject) => {
console.log(111);
});
console.log(222);
// 输出顺序:111 → 222
这一点常被误解为”Promise 让代码变异步了”。实际上执行器同步执行,只有它注册的 then 回调才是异步(微任务)执行的。
const p = new Promise((resolve, reject) => {
// 这里写异步操作
setTimeout(() => {
const ok = Math.random() > 0.5;
if (ok) {
resolve("成功了"); // pending => fulfilled
} else {
reject("失败了"); // pending => rejected
}
}, 1000);
});
p.then(
value => console.log("成功:" + value),
reason => console.log("失败:" + reason)
);
3.2 then 方法
then 接收两个可选参数:成功回调和失败回调,二者都只会有一个被调用,且只被调用一次。
p.then(
value => { /* fulfilled 时执行 */ },
reason => { /* rejected 时执行 */ }
);
// 只关心成功
p.then(value => console.log(value));
// 只关心失败(等价于 p.then(null, reason => {}))
p.then(null, reason => console.error(reason));
then 注册的回调不会被同步执行,而是进入微任务队列,等当前同步代码全部跑完才开始执行。
console.log("start");
Promise.resolve().then(() => console.log("promise"));
console.log("end");
// 输出顺序:start → end → promise
同一个 Promise 可以被多次 then
状态确定后,所有注册过的回调都会被调用,且拿到的是同一个结果值。
let p = new Promise((resolve, reject) => {
resolve("ok");
});
p.then(value => console.log(value)); // ok
p.then(value => console.log(value)); // ok
3.3 catch 方法
catch(onRejected) 是 then(null, onRejected) 的语法糖,专门用于处理失败。
p.then(value => console.log(value))
.catch(reason => console.error(reason));
3.4 finally 方法
finally 的回调无论成功失败都会执行,适合做收尾工作(关闭 loading、释放资源)。它接收不到结果值,也不会改变已经确定的结果。
p.then(value => console.log(value))
.catch(reason => console.error(reason))
.finally(() => console.log("无论如何都会执行"));
4. 封装 fs 模块
把 Node.js 里基于回调的 fs.readFile 包装成返回 Promise 的函数——这是 Promise 最经典的应用之一。
const fs = require("fs");
function get(path) {
return new Promise((resolve, reject) => {
fs.readFile(path, "utf-8", (err, data) => {
if (err) {
reject(err);
return; // 记得 return,避免失败后又 resolve
}
resolve(data);
});
});
}
get("./content.txt").then(
value => console.log(value.toString()),
reason => console.log(reason)
);
更简单的做法:util.promisify
Node.js 内置的 util.promisify 可以把任何 错误优先(error-first)回调风格的函数一次性转成返回 Promise 的函数,无需手写包装。
const util = require("util");
const fs = require("fs");
let get = util.promisify(fs.readFile);
get("./content.txt").then(value => {
console.log(value.toString());
});
只要是形如 fn(args..., (err, result) => {}) 的 API,都可以用 util.promisify 转换。
5. 封装 AJAX
把浏览器原生 XMLHttpRequest 包装成返回 Promise 的函数。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<script>
function send(url) {
return new Promise((resolve, reject) => {
const xhr = new XMLHttpRequest();
xhr.open("GET", url);
xhr.send();
xhr.addEventListener("readystatechange", () => {
if (xhr.readyState === 4) {
if (xhr.status >= 200 && xhr.status < 300) {
resolve(xhr.response);
} else {
reject(xhr.status);
}
}
});
});
}
send("http://localhost:8030/serve").then(
value => console.log(value),
reason => console.log(reason)
);
</script>
</body>
</html>
别忘了错误处理
xhr 的网络层错误会触发 onerror,上面的例子没有监听。生产环境中建议补上:
xhr.onerror = () => reject(new Error("网络异常"));
现代浏览器中,fetch 本身就返回 Promise,是更推荐的选择。
6. Promise 的静态方法
6.1 方法速查表
| 方法 | 作用 | 成功条件 | 失败条件 |
|---|---|---|---|
Promise.resolve(v) |
快速得到一个 Promise | 由参数决定 | 参数是失败 Promise 时为失败 |
Promise.reject(r) |
快速得到一个失败 Promise | — | 永远失败 |
Promise.all(arr) |
并发执行,全部成功才算成功 | 全部 fulfilled | 任意一个 rejected |
Promise.race(arr) |
赛跑,取最先改变状态的结果 | 最先 fulfilled | 最先 rejected |
Promise.allSettled(arr) |
等待全部结束,永不失败 | 总是成功,返回结果数组 | — |
Promise.any(arr) |
取最先成功的那个 | 任意一个 fulfilled | 全部 rejected |
6.2 Promise.resolve
传入的参数是非 Promise 的值(普通值或普通对象),返回的结果就是成功的 Promise 对象,其值为该参数。
传入的参数是 Promise 对象,则参数的结果决定了
resolve的结果。
let p1 = Promise.resolve(5222);
console.log(p1); // Promise {<fulfilled>: 5222}
// 传入 Promise,结果跟随该 Promise
let p2 = Promise.resolve(Promise.reject("boom"));
console.log(p2); // Promise {<rejected>: "boom"}
6.3 Promise.reject
返回一个失败的 Promise 对象。
let p2 = Promise.reject("sdalds");
console.log(p2); // Promise {<rejected>: "sdalds"}
务必处理 reject
Promise.reject 产生的失败如果没有被 catch 处理,会在控制台抛出 UnhandledPromiseRejection 警告(Node.js 中甚至会直接终止进程)。任何 Promise 链的末尾都建议加上 catch。
6.4 Promise.all
接收一个包含 n 个 Promise 的数组,返回一个新的 Promise:只有所有 Promise 都成功才成功,返回值是各结果按原顺序组成的数组;只要有一个失败就整体失败。
const pro1 = new Promise((resolve, reject) => { resolve("OK"); });
const pro2 = new Promise((resolve, reject) => { resolve("OK"); });
const pro3 = new Promise((resolve, reject) => { resolve("OK"); });
let res = Promise.all([pro1, pro2, pro3]);
console.log(res); // Promise {<fulfilled>: ["OK", "OK", "OK"]}
快速失败(fail fast)
Promise.all 是并行执行的,但只要其中一个 reject,整个 all 立刻 reject,其余 Promise 的结果会被丢弃(虽然它们的异步操作仍在继续)。
如果你希望”无论成败都等全部完成”,请用 Promise.allSettled。
6.5 Promise.race
返回一个新的 Promise,结果是第一个改变状态的 Promise 的结果(无论成功还是失败)。
Promise.all vs Promise.race
all:等待全部,全部成功才成功——适用于”多个依赖必须都拿到”的场景。race:只取最快,谁先出结果就用谁——适用于”超时控制”这类场景。
// 用 race 实现超时控制:5 秒内没拿到结果就判定失败
function timeout(promise, ms) {
let timer = new Promise((resolve, reject) => {
setTimeout(() => reject(new Error("请求超时")), ms);
});
return Promise.race([promise, timer]);
}
timeout(fetch("/api/data"), 5000)
.then(res => res.json())
.catch(err => console.error(err.message));
6.6 Promise.allSettled
等待所有 Promise 都结束(不管成功失败),永远不会失败。返回值是每个 Promise 的结果对象数组,status 为 fulfilled 或 rejected。
Promise.allSettled([
Promise.resolve(1),
Promise.reject("err")
]).then(results => {
console.log(results);
// [
// { status: "fulfilled", value: 1 },
// { status: "rejected", reason: "err" }
// ]
});
6.7 Promise.any
取最先成功的那个 Promise 的结果;只有当全部都失败时才失败,失败原因是 AggregateError。
Promise.any([
Promise.reject("A 失败"),
Promise.resolve("B 成功"),
Promise.resolve("C 成功")
]).then(value => console.log(value)); // B 成功
7. Promise 的关键问题
7.1 如何改变 Promise 的状态
改变状态一共有三种途径:
let p = new Promise((resolve, reject) => {
// 1. pending => fulfilled
resolve("ok");
// 2. pending => rejected
reject("error");
// 3. pending => rejected(执行器中抛出的异常也会让 Promise 失败)
throw "error";
});
console.log(p);
throw 也会被捕获
执行器中 throw 出的异常会被 new Promise 内部用 try...catch 捕获,并自动转为失败状态——这正是自定义封装时必须处理的地方。
注意:如果状态已经确定(比如先调用了 resolve),后续再 throw 就不会再改变状态了。
7.2 多次回调都会被调用
状态改变后,注册的所有回调都会被依次调用。
let p = new Promise((resolve, reject) => {
resolve("ok");
});
p.then(value => {
console.log(value);
});
p.then(value => {
alert("1");
});
7.3 then 的返回结果由回调函数决定
then 方法本身总是返回一个全新的 Promise,这个新 Promise 的状态和值,由指定的回调函数的执行结果决定:
抛出异常
回调中 throw 或运行时出错 ⇒ 新 Promise 失败,值为抛出的异常。
返回非 Promise
回调返回一个普通值 ⇒ 新 Promise 成功,值为该返回值。
返回 Promise
回调返回一个 Promise ⇒ 新 Promise 的状态和结果完全由这个返回的 Promise 决定。
没有返回
回调没有返回值(即 undefined)⇒ 新 Promise 成功,值为 undefined。
let p = new Promise((resolve, reject) => {
resolve("ok");
});
p.then(value => {
console.log(1);
// 1. 抛出错误 => 新 Promise 失败,值为 "错误"
throw "错误";
// 2. 返回普通值 => 新 Promise 成功,值为 "sdad"
return "sdad";
// 3. 返回 Promise => 新 Promise 的结果就是 then 返回的这个 Promise 的结果
return new Promise((resolve, reject) => { resolve("ok"); });
}, reason => {
console.log(2);
});
这正是链式调用的根基
因为 then 永远返回一个新 Promise,所以可以无限 .then() 下去。每一次的结果都会作为下一次的输入,形成一条清晰的数据管道:
new Promise(resolve => resolve(1))
.then(v => v + 1) // 2
.then(v => v * 10) // 20
.then(v => Promise.resolve(v + 5)) // 25,跟随返回的 Promise
.then(v => console.log(v)); // 25
7.4 异常穿透
当使用 then 的链式调用时,可以在最后用 catch 统一指定失败的回调。前面任何一步出现的异常(包括没有写失败回调的 then),都会一路向下穿透,被最后的 catch 捕获。
let p = new Promise((resolve, reject) => {
resolve("ok");
});
p.then(value => {
console.log(1);
}, reason => {
console.log(2);
}).then(value => {
console.log(value);
}).then(value => {
console.log(value);
}).catch(reason => {
console.log(reason); // 前面任意环节出错,都会落到这里
});
为什么能穿透
因为当某个 then 没有指定失败回调时,会用默认的失败回调 reason => { throw reason; } 把错误原样再抛出去,于是错误就被下一个 Promise 继承,一直传到遇到 catch 为止。
7.5 中断 Promise 链
想在某个环节中断后续的链式调用,唯一的方法是返回一个 pending 状态的 Promise——因为后续 then 的回调需要在这个 Promise 状态改变后才会执行,而它永远不会改变。
p.then(value => {
console.log(1);
// 唯一方法:返回一个 pending 状态的 Promise
return new Promise(() => {});
}, reason => {
console.log(2);
}).then(value => {
console.log(value); // ❌ 不会执行
}).then(value => {
console.log(value); // ❌ 不会执行
}).catch(reason => {
console.log(reason); // ❌ 不会执行
});
8. 手写实现 Promise
下面是一个遵循 Promise/A+ 规范核心思想的自定义封装,完整覆盖状态管理、异步回调、链式调用以及各个静态方法。
/* 封装为一个类 */
class Promise {
constructor(executor) {
// 1. 初始状态
this.PromiseState = 'pending';
// 2. 初始结果
this.PromiseResult = null;
// 3. 保存 pending 状态下注册的回调
this.callbacks = [];
/* 保存实例对象的 this 值 */
const self = this;
function resolve(data) {
// 状态只能改变一次
if (self.PromiseState !== 'pending') return;
self.PromiseState = 'fulfilled';
self.PromiseResult = data;
// 异步执行已保存的成功回调
setTimeout(() => {
self.callbacks.forEach(item => {
item.onResolved(data);
});
});
}
function reject(data) {
if (self.PromiseState !== 'pending') return;
self.PromiseState = 'rejected';
self.PromiseResult = data;
// 异步执行已保存的失败回调
setTimeout(() => {
self.callbacks.forEach(item => {
item.onRejected(data);
});
});
}
// 同步调用执行器函数,捕获其中抛出的异常
try {
executor(resolve, reject);
} catch (e) {
reject(e);
}
}
then(onResolved, onRejected) {
const self = this;
// 异常穿透:没有传失败回调时,默认把错误继续往下抛
if (typeof onRejected !== 'function') {
onRejected = reason => { throw reason; };
}
// 值穿透:没有传成功回调时,默认把结果继续往下传
if (typeof onResolved !== 'function') {
onResolved = value => value;
}
return new Promise((resolve, reject) => {
function callback(type) {
try {
let result = type(self.PromiseResult);
if (result instanceof Promise) {
// 返回 Promise:结果由它决定
result.then(v => resolve(v), r => reject(r));
} else {
// 返回普通值:直接成功
resolve(result);
}
} catch (e) {
// 抛出异常:直接失败
reject(e);
}
}
if (this.PromiseState === 'fulfilled') {
setTimeout(() => callback(onResolved));
}
if (this.PromiseState === 'rejected') {
setTimeout(() => callback(onRejected));
}
if (this.PromiseState === 'pending') {
// 状态未定,先把回调保存起来,等状态改变时再执行
this.callbacks.push({
onResolved: function () { callback(onResolved); },
onRejected: function () { callback(onRejected); }
});
}
});
}
catch(onRejected) {
return this.then(undefined, onRejected);
}
// 静态方法 resolve
static resolve(value) {
return new Promise((resolve, reject) => {
if (value instanceof Promise) {
value.then(v => resolve(v), r => reject(r));
} else {
resolve(value);
}
});
}
// 静态方法 reject
static reject(reason) {
return new Promise((resolve, reject) => {
reject(reason);
});
}
// 静态方法 all:全部成功才成功
static all(promises) {
return new Promise((resolve, reject) => {
let count = 0;
let arr = [];
for (let i = 0; i < promises.length; i++) {
promises[i].then(v => {
count++;
arr[i] = v; // 结果按原顺序存放
if (count === promises.length) {
resolve(arr); // 全部成功,返回数组
}
}, r => {
reject(r); // 一个失败,整体失败
});
}
});
}
// 静态方法 race:取最先改变状态的结果
static race(promises) {
return new Promise((resolve, reject) => {
for (let i = 0; i < promises.length; i++) {
promises[i].then(v => resolve(v), r => reject(r));
}
});
}
}
实现要点回顾
- 状态锁:
resolve/reject里第一件事就是判断当前是否为pending,这保证了状态只改变一次。 - 回调异步执行:用
setTimeout包裹,模拟微任务的异步语义,确保then回调不会同步调用。 - 回调缓存:
pending时把回调存进callbacks数组,状态改变后再统一取出执行。 - 异常捕获:执行器和每个回调都用
try...catch包裹,异常一律转为失败。 - then 返回新 Promise:
.then内部return new Promise(...),这是链式调用与异常穿透的基础。 - 原生 Promise 用的是微任务:这里用
setTimeout(宏任务)只是为了模拟,规范实现应使用queueMicrotask或MutationObserver。
9. async 与 await
async/await 是 ES2017 引入的语法糖,它建立在 Promise 之上,让你用写同步代码的方式写异步代码,彻底消灭了 .then 的嵌套。
9.1 async 函数
被 async 修饰的函数,其返回值一定是一个 Promise 对象:
- 返回一个非 Promise 值 ⇒ 结果为成功的 Promise,值为该返回值
- 返回一个 Promise ⇒ 结果由这个 Promise 决定
- 抛出异常 ⇒ 结果为失败的 Promise,值为抛出的异常
async function main() {
return new Promise((resolve, reject) => {
// resolve("OK");
reject("ERROR");
});
throw "DZ"; // 注意:上面已经 return 了,这行不会执行
}
let result = main();
console.log(result); // Promise {<rejected>: "ERROR"}
也可以直接用 await 接住异常
async 函数的返回值是 Promise,所以用 .catch() 或 await 配合 try...catch 都能处理失败。
9.2 await 表达式
await必须写在async函数中,但async函数中可以没有await。
await右侧一般是 Promise 对象,得到的是它成功的值;如果右侧是普通值,则直接返回该值本身。如果
await的 Promise 失败了,就会抛出异常,需要通过try...catch捕获处理。
async function main() {
let p = new Promise((resolve, reject) => {
// resolve("OK");
reject("ERROR");
});
/* let res = await p;
console.log(res);
let res2 = await 20; // 非 Promise,直接得到 20
console.log(res2); */
try {
let res = await p;
} catch (e) {
console.log(e); // ERROR
}
}
await 会阻塞(仅阻塞 async 函数内部)
await 会暂停当前 async 函数的执行,等待 Promise 落定后再继续。但它不会阻塞主线程,外面的同步代码照常运行。这也是它比同步阻塞写法优越的原因。
9.3 并发还是串行
await 默认是串行的,前一个完成才会执行下一个。如果需要并发,请配合 Promise.all。
// ⚠️ 串行:总共耗时 ≈ 三者之和
const a = await task1();
const b = await task2();
const c = await task3();
// ✅ 并发:总共耗时 ≈ 最慢的那个
const [a, b, c] = await Promise.all([task1(), task2(), task3()]);
注意:不要在循环中直接 await
// ❌ 串行,n 次请求叠加耗时
for (const url of urls) {
await fetch(url);
}
// ✅ 并发,一次性发出
await Promise.all(urls.map(url => fetch(url)));
9.4 结合案例
同一个”读取三个文件并拼接”的需求,三种写法的演进:
const fs = require("fs");
const util = require("util");
const mineReadFile = util.promisify(fs.readFile);
/* ① 回调地狱写法
fs.readFile("../res/1.html", "utf-8", (err, datastr1) => {
if (err) throw err;
fs.readFile("../res/2.html", "utf-8", (err, datastr2) => {
if (err) throw err;
fs.readFile("../res/3.html", "utf-8", (err, datastr3) => {
if (err) throw err;
console.log(datastr1 + " " + datastr2 + " " + datastr3);
});
});
}); */
/* ② async/await 串行写法(示例中原写法三个路径相同,实际应分别为 1/2/3.html) */
async function main() {
let datastr1 = await mineReadFile("../res/1.html");
let datastr2 = await mineReadFile("../res/2.html");
let datastr3 = await mineReadFile("../res/3.html");
console.log(datastr1 + " " + datastr2 + " " + datastr3);
}
main();
/* ③ 并发写法:三个文件同时读取,效率更高 */
async function mainFast() {
const arr = await Promise.all([
mineReadFile("../res/1.html"),
mineReadFile("../res/2.html"),
mineReadFile("../res/3.html")
]);
console.log(arr.join(" "));
}
mainFast();
10. 实践要点
每个 Promise 链都以 catch 收尾
未被捕获的 rejection 会变成 UnhandledPromiseRejection,在 Node.js 中甚至会让进程崩溃。
注意 return 的重要性
then 回调里如果调用异步操作却**忘记 return**,外层链就等不到它,结果会丢失。
all vs allSettled 要分清
要求”缺一不可”用 all;只要全部跑完、允许部分失败用 allSettled。
用 race 做超时控制
网络请求务必加超时兜底,避免无限期挂起。
循环里别直接 await
需要并发时用 Promise.all(arr.map(...)),否则会退化成串行。
async 函数返回值永远是 Promise
即便 return 1,外面拿到的也是 Promise {<fulfilled>: 1}。
附:核心 API 一览
| API | 语法 | 说明 |
|---|---|---|
new Promise(executor) |
new Promise((resolve, reject) => {}) |
创建一个 Promise,执行器同步立即执行 |
then |
p.then(onResolved, onRejected) |
注册回调,返回新的 Promise |
catch |
p.catch(onRejected) |
捕获失败,等价于 then(null, onRejected) |
finally |
p.finally(onFinally) |
无论成败都会执行,接收不到结果值 |
resolve |
Promise.resolve(value) |
快速得到一个 Promise,结果由参数决定 |
reject |
Promise.reject(reason) |
快速得到一个失败的 Promise |
all |
Promise.all([p1, p2, ...]) |
全部成功才成功,返回结果数组 |
race |
Promise.race([p1, p2, ...]) |
取最先落定的那个结果 |
allSettled |
Promise.allSettled([p1, p2, ...]) |
等待全部结束,永不失败 |
any |
Promise.any([p1, p2, ...]) |
取最先成功的那个,全失败才失败 |
async |
async function fn() {} |
声明异步函数,返回值必为 Promise |
await |
const v = await p |
等待 Promise 结果,只能在 async 内使用 |
一句话总结:Promise 用”一个代表未来的值的对象”取代了层层嵌套的回调;而
async/await又把这个对象还原成了看起来像同步的代码——两者结合,才是现代 JavaScript 异步编程的标准写法。