Promise有哪些方法

Promise 提供了丰富的实例方法和静态方法来处理异步操作。以下是 Promise 的主要方法：

一、实例方法（在 Promise 对象上调用）

1. then(onFulfilled, onRejected)

promise.then(
  value => { /* 处理成功 */ },
  reason => { /* 处理失败 */ }
)

• 注册成功和失败的回调
• 返回一个新的 Promise，支持链式调用

2. catch(onRejected)

promise.catch(error => {
  console.error('捕获错误:', error);
})

• 专门处理 Promise 失败的情况
• 相当于 .then(null, onRejected)

3. finally(onFinally)

promise.finally(() => {
  console.log('无论成功失败都会执行');
})

• 无论 Promise 成功还是失败都会执行
• 适合做清理工作

二、静态方法（在 Promise 类上调用）

1. Promise.resolve(value)

// 创建一个已解决的 Promise
Promise.resolve('成功数据')
  .then(data => console.log(data)); // "成功数据"

// 如果参数是 Promise，则原样返回
Promise.resolve(existingPromise) === existingPromise

2. Promise.reject(reason)

// 创建一个已拒绝的 Promise
Promise.reject(new Error('失败原因'))
  .catch(error => console.error(error));

3. Promise.all(iterable)

const p1 = Promise.resolve(1);
const p2 = Promise.resolve(2);
const p3 = Promise.resolve(3);

Promise.all([p1, p2, p3])
  .then(values => {
    console.log(values); // [1, 2, 3]
  })
  .catch(error => {
    // 任何一个失败就进入这里
    console.error(error);
  });

• 所有 Promise 都成功才成功
• 有一个失败就立即失败（快速失败）

4. Promise.allSettled(iterable)

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

Promise.allSettled([p1, p2, p3])
  .then(results => {
    results.forEach(result => {
      if (result.status === 'fulfilled') {
        console.log('成功:', result.value);
      } else {
        console.log('失败:', result.reason);
      }
    });
  });

• 所有 Promise 都完成后返回结果
• 无论成功失败都会等到所有完成

5. Promise.any(iterable)

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

Promise.any([p1, p2, p3])
  .then(value => {
    console.log('第一个成功的:', value); // "成功2"
  })
  .catch(error => {
    // 所有 Promise 都失败时进入这里
    console.error('全部失败:', error);
  });

• 任意一个 Promise 成功就成功
• 所有都失败时才失败

6. Promise.race(iterable)

const fast = new Promise(resolve => 
  setTimeout(() => resolve('快'), 100)
);
const slow = new Promise(resolve => 
  setTimeout(() => resolve('慢'), 500)
);

Promise.race([fast, slow])
  .then(winner => {
    console.log('胜者:', winner); // "快"
  });

• 第一个 完成的 Promise（无论成功失败）
• 常用于设置超时

三、方法对比表

方法	成功条件	失败条件	返回内容
Promise.all	全部成功	一个失败	成功值数组
Promise.allSettled	全部完成	不会失败	状态对象数组
Promise.any	一个成功	全部失败	第一个成功的值
Promise.race	第一个完成	第一个完成	第一个完成的值

四、使用示例

// 组合使用示例
const apiCall1 = fetch('/api/data1');
const apiCall2 = fetch('/api/data2');
const apiCall3 = fetch('/api/data3');

// 并行请求，全部完成后处理
Promise.allSettled([apiCall1, apiCall2, apiCall3])
  .then(results => {
    const successes = results
      .filter(r => r.status === 'fulfilled')
      .map(r => r.value);
    const failures = results
      .filter(r => r.status === 'rejected')
      .map(r => r.reason);
    
    console.log('成功:', successes.length, '失败:', failures.length);
  });

// 超时控制
function withTimeout(promise, timeout) {
  return Promise.race([
    promise,
    new Promise((_, reject) => 
      setTimeout(() => reject(new Error('超时')), timeout)
    )
  ]);
}

// 等待至少一个接口成功
Promise.any([
  fetch('/api/primary'),
  fetch('/api/backup1'),
  fetch('/api/backup2')
])
  .then(data => displayData(data))
  .catch(() => showError('所有接口都失败了'));

五、Promise 原型方法

// 这些是内部方法，通常不直接使用
Promise.prototype.then
Promise.prototype.catch
Promise.prototype.finally
Promise.prototype.constructor

Promise 的这些方法提供了灵活的组合和处理异步操作的能力，可以应对各种复杂的异步场景。