Promise对象是JavaScript中处理异步操作的核心机制，通过pending、fulfilled和rejected三种状态管理异步流程，解决回调地狱问题；使用then、catch、finally链式调用处理成功与失败，支持Promise.all（全成功才成功）、Promise.race（首个完成即返回）和Promise.allSettled（全部完成才返回结果数组）等静态方法处理多个异步任务，结合async/await语法可让异步代码更简洁易读，但需注意错误处理、避免过度链式调用及合理选择并发控制策略。
Promise 对象本质上是 JavaScript 中处理异步操作的一种方式。它代表了一个尚未完成但预期将来会完成的操作。你可以把它想象成一张兑奖券，承诺将来会给你一个结果（成功或失败）。
它主要解决了传统回调函数可能导致的回调地狱问题，让异步代码更加易于阅读和维护。
解决方案：
Promise 对象有三种状态：
- pending (进行中): 初始状态，表示异步操作尚未完成。
- fulfilled (已成功): 异步操作成功完成。
- rejected (已失败): 异步操作失败。
Promise 对象的状态一旦改变，就不会再变，只能从 pending 变为 fulfilled 或 rejected。
创建 Promise 对象：
const myPromise = new Promise((resolve, reject) => {
// 异步操作
setTimeout(() => {
const success = true; // 假设操作成功
if (success) {
resolve("操作成功！"); // 将 Promise 状态变为 fulfilled，并传递成功的值
} else {
reject("操作失败！"); // 将 Promise 状态变为 rejected，并传递失败的原因
}
}, 1000);
});使用 Promise 对象：
myPromise
.then((value) => {
// 处理成功的情况
console.log(value); // 输出 "操作成功！"
return "链式调用"; // 可以返回一个新的值，传递给下一个 then
})
.catch((reason) => {
// 处理失败的情况
console.error(reason); // 输出 "操作失败！"
})
.finally(() => {
// 无论成功或失败，都会执行
console.log("操作完成！");
});then()方法用于处理 Promise 对象成功的情况，它接收一个回调函数，该回调函数接收 Promise 对象成功的值。
catch()方法用于处理 Promise 对象失败的情况，它接收一个回调函数，该回调函数接收 Promise 对象失败的原因。
finally()方法用于无论 Promise 对象成功或失败，都会执行的回调函数。
Promise 链式调用：
Promise 的
then()方法可以返回一个新的 Promise 对象，从而实现链式调用。这使得异步代码更加易于阅读和维护。
new Promise((resolve, reject) => {
resolve(1);
})
.then((value) => {
console.log(value); // 1
return value + 1;
})
.then((value) => {
console.log(value); // 2
return value + 1;
})
.then((value) => {
console.log(value); // 3
});为什么需要 Promise？回调地狱是什么？
回调地狱指的是当异步操作嵌套过多时，代码会变得难以阅读和维护。例如：
技术上面应用了三层结构，AJAX框架，URL重写等基础的开发。并用了动软的代码生成器及数据访问类，加进了一些自己用到的小功能，算是整理了一些自己的操作类。系统设计上面说不出用什么模式，大体设计是后台分两级分类，设置好一级之后，再设置二级并选择栏目类型，如内容，列表，上传文件，新窗口等。这样就可以生成无限多个二级分类，也就是网站栏目。对于扩展性来说，如果有新的需求可以直接加一个栏目类型并新加功能操作
asyncOperation1(function(result1) {
asyncOperation2(result1, function(result2) {
asyncOperation3(result2, function(result3) {
// ... 更多嵌套
});
});
});这种代码结构会导致代码缩进过多，逻辑混乱，难以追踪错误。Promise 通过链式调用和状态管理，可以有效地解决回调地狱问题。
使用 Promise 重写上面的代码：
asyncOperation1()
.then(result1 => asyncOperation2(result1))
.then(result2 => asyncOperation3(result2))
.then(result3 => {
// ...
})
.catch(error => {
console.error(error); // 统一处理错误
});可以看到，使用 Promise 后，代码结构更加清晰，易于阅读和维护。
Promise.all、Promise.race、Promise.allSettled 的区别是什么？
这三个方法都是 Promise 提供的静态方法，用于处理多个 Promise 对象。
-
Promise.all(promises): 接收一个 Promise 对象数组，当数组中所有的 Promise 对象都成功时，返回一个新的 Promise 对象，该 Promise 对象的值是包含所有 Promise 对象成功值的数组。如果数组中任何一个 Promise 对象失败，则返回的 Promise 对象也会失败，失败的原因是第一个失败的 Promise 对象的原因。
const promise1 = Promise.resolve(1); const promise2 = Promise.resolve(2); const promise3 = Promise.resolve(3); Promise.all([promise1, promise2, promise3]) .then(values => { console.log(values); // [1, 2, 3] }) .catch(error => { console.error(error); }); -
Promise.race(promises): 接收一个 Promise 对象数组，返回一个新的 Promise 对象，该 Promise 对象的状态和值与数组中第一个改变状态的 Promise 对象相同。也就是说，哪个 Promise 对象最先完成（成功或失败），就返回哪个 Promise 对象的结果。
const promise1 = new Promise(resolve => setTimeout(() => resolve(1), 1000)); const promise2 = new Promise(resolve => setTimeout(() => resolve(2), 500)); Promise.race([promise1, promise2]) .then(value => { console.log(value); // 2 }) .catch(error => { console.error(error); }); -
Promise.allSettled(promises): 接收一个 Promise 对象数组，返回一个新的 Promise 对象，该 Promise 对象在所有 Promise 对象都完成（成功或失败）后才完成。返回的 Promise 对象的值是一个包含每个 Promise 对象结果的数组，每个结果对象都有一个
status
属性，表示 Promise 对象的状态（fulfilled
或rejected
），以及一个value
属性（如果 Promise 对象成功）或一个reason
属性（如果 Promise 对象失败）。const promise1 = Promise.resolve(1); const promise2 = Promise.reject(2); Promise.allSettled([promise1, promise2]) .then(results => { console.log(results); // [ // { status: 'fulfilled', value: 1 }, // { status: 'rejected', reason: 2 } // ] }) .catch(error => { console.error(error); });
如何使用 async/await 简化 Promise 的使用？
async/await是 JavaScript 中用于简化异步操作的语法糖，它基于 Promise 对象。
async函数会隐式地返回一个 Promise 对象，而
await关键字用于等待一个 Promise 对象完成。
async function myAsyncFunction() {
try {
const result1 = await asyncOperation1();
const result2 = await asyncOperation2(result1);
const result3 = await asyncOperation3(result2);
console.log(result3);
} catch (error) {
console.error(error);
}
}
myAsyncFunction();这段代码等价于：
asyncOperation1()
.then(result1 => asyncOperation2(result1))
.then(result2 => asyncOperation3(result2))
.then(result3 => {
console.log(result3);
})
.catch(error => {
console.error(error);
});async/await使得异步代码看起来像同步代码，更加易于阅读和维护。需要注意的是，
await关键字只能在
async函数中使用。
Promise 的一些常见错误使用方式有哪些？
-
忘记处理 rejected 状态: 如果 Promise 对象 rejected，但没有使用
catch()
方法处理，会导致错误被忽略，可能会导致程序出现意外行为。 -
在
then()
方法中返回非 Promise 对象: 如果在then()
方法中返回一个非 Promise 对象，该值会被包装成一个 resolved 的 Promise 对象，这可能会导致一些意外的行为。 - 过度使用 Promise 链: 虽然 Promise 链可以使代码更加清晰，但过度使用 Promise 链也会导致代码难以阅读和维护。应该根据实际情况选择合适的异步处理方式。
-
混淆 Promise.all 和 Promise.race 的使用场景:
Promise.all
适用于需要等待所有 Promise 对象都完成的场景，而Promise.race
适用于只需要等待其中一个 Promise 对象完成的场景。混淆使用会导致程序行为不符合预期。 - 没有正确处理并发请求: 在处理并发请求时，需要注意控制并发数量，避免对服务器造成过大的压力。可以使用 Promise 结合信号量等机制来实现并发控制。
