（四）前端，如此简单！---Promise

如果说 Fetch 解决了"前端如何获取数据"的问题，那么 Promise 解决的则是"拿到数据后如何优雅、可靠地处理异步逻辑"的问题。

Promise创建时一定是 pending(等待中)，一个 Promise 只能从 pending 变为 fulfilled 或 rejected，且状态一旦改变就不可逆。

一、Promise.all()

const promise = Promise.all(iterable);	//全部成功，返回状态为 fulfilled 的 Promise
promise				   // 一旦 iterable 中有一个 Promise 被 reject，Promise.all 返回的 Promise 就会立即 reject
  .then(results => {				  // 并携带第一个被拒绝的 Promise 的错误原因
    console.log('全部成功，结果数组：', results);  // 其他 Promise 不会停止执行，只是结果被忽略 
  })
  .catch(error => {
    console.error('第一个失败的原因：', error);
  });

二、Promise.allSettled()

const promise = Promise.allSettled(iterable);   // 等待所有 Promise 完成（无论成功或失败），返回的 Promise 始终为 fulfilled
promise										  // 结果Promise数组中，每个元素都有 status 属性，值为 'fulfilled' 或 'rejected'
  .then(results => {
    console.log('所有 Promise 都已 settled，结果数组：', results);
    // results 是一个数组，每个元素是一个对象：
    // 如果对应 Promise 成功：{ status: 'fulfilled', value: 成功值 }
    // 如果对应 Promise 失败：{ status: 'rejected', reason: 失败原因 }
  })
  // 注意：Promise.allSettled 永远不会进入 catch，因为它总是 resolve
  .finally(() => {
    console.log('操作结束，无论成功或失败');
  });

三、Promise.any()

• 只要迭代器中的任何一个 Promise 成功（fulfilled），返回的 Promise 就会立即以该成功值解决。
• 如果所有 Promise 都拒绝，则返回的 Promise 才会拒绝，并抛出一个 AggregateError 实例，其 errors 属性包含所有拒绝原因的数组。

其他传入的 Promise 仍然会继续执行，并不会被取消或中止，它们的最终结果会被忽略。

const p1 = Promise.reject('错误1');
const p2 = Promise.resolve('成功');
const p3 = Promise.reject('错误2');

Promise.any([p1, p2, p3])
  .then(value => console.log('成功:', value))  // 输出: 成功: 成功
  .catch(err => console.log('全部失败:', err.errors));

Promise.any([p1, p3])
  .then(value => console.log('成功:', value))
  .catch(err => {
    console.log(err instanceof AggregateError); // true
    console.log(err.errors); // ['错误1', '错误3']
  });

四、Promise.race()

迭代器中的任何一个 Promise 被解决（fulfilled）或拒绝（rejected），就返回该 Promise。

其他传入的 Promise 仍然会继续执行，并不会被取消或中止，它们的最终结果会被忽略。

五、Promise.resolve()

• 如果参数是 Promise 实例，直接返回原 Promise 实例
• 如果参数不是 Promise（如普通值、对象等）：返回一个以该值为成功结果的新的 fulfilled Promise。

六、Promise.reject()

• 总是返回一个新的 rejected Promise，始终以传入的参数作为拒绝原因

  const resolvedPromise = Promise.resolve('成功'); // 新的 状态为 fulfilled 的 Promise
  const rejectedPromise = Promise.reject('失败'); // 新的 状态为 rejected 的 Promise

  resolvedPromise.then( // fulfilled Promise.then 执行第一个回调
  (value) => console.log('✅ onFulfilled 执行:', value), // ✅ onFulfilled 执行: 成功
  (reason) => console.log('❌ onRejected 执行:', reason) // 不执行
  );

  rejectedPromise.then( // rejected Promise.then 执行第二个回调
  (value) => console.log('✅ onFulfilled 执行:', value), // 不执行
  (reason) => console.log('❌ onRejected 执行:', reason) // ❌ onRejected 执行: 失败
  );

  rejectedPromise.catch( // .catch 只有一个回调
  (reason) => console.log('拒绝原因:', reason) // 拒绝原因: 失败
  );

七、Promise.withResolve

返回一个包含 promise 的对象，并带一个成功和一个拒绝

//  可以轻松创建能外部控制的 Promise
const { promise, resolve, reject } = Promise.withResolvers();
// promise: Promise, resolve: function resolve, reject: function reject

八、传入空数组会发生什么

方法	空数组 [] 的结果	状态	说明
Promise.all([])	Promise {<fulfilled>: []}	✅ 立即成功	空真，安全
Promise.allSettled([])	Promise {<fulfilled>: []}	✅ 立即成功	空真，安全
Promise.race([])	Promise {<pending>}	⏳ 永远挂起	危险！内存泄漏
Promise.any([])	Promise {<rejected>: AggregateError}	❌ 立即失败	All promises were rejected
Promise.resolve([])	Promise {<fulfilled>: []}	✅ 立即成功	包装为 Promise
Promise.reject([])	Promise {<rejected>: []}	❌ 立即失败	原因是空数组
Promise.withResolvers()	非数组方法	-	创建 {promise, resolve, reject}