Promise的静态方法有哪些，分别怎么使用？

Promise的静态方法是挂载在Promise构造函数上的方法，不需要创建Promise实例就可以直接调用，这些方法在处理多异步任务协作、异步结果转换等场景中非常实用，下面先介绍常用的几个静态方法。

Promise.resolve

Promise.resolve方法用于将一个值快速转换为一个状态为 fulfilled 的Promise对象，它的参数如果是Promise实例则会直接返回该实例，如果是thenable对象（包含then方法的对象）则会跟随该对象的执行状态，其他普通值则会作为fulfilled状态的返回值。

// 传入普通值
const p1 = Promise.resolve(123);
p1.then(res => {
  console.log(res); // 输出123
});

// 传入Promise实例
const p2 = new Promise(resolve => resolve('test'));
const p3 = Promise.resolve(p2);
console.log(p1 === p2); // 输出false
console.log(p3 === p2); // 输出true

// 传入thenable对象
const thenable = {
  then(resolve) {
    resolve('thenable result');
  }
};
Promise.resolve(thenable).then(res => {
  console.log(res); // 输出thenable result
});

Promise.reject

Promise.reject方法用于创建一个状态为 rejected 的Promise对象，无论传入什么参数，都会直接作为拒绝的原因，不会像Promise.resolve那样对参数做特殊处理。

const p = Promise.reject(new Error('请求失败'));
p.catch(err => {
  console.log(err.message); // 输出请求失败
});

// 传入thenable对象也会直接作为拒绝原因
const thenable = {
  then() {}
};
Promise.reject(thenable).catch(err => {
  console.log(err === thenable); // 输出true
});

Promise.all

Promise.all接收一个可迭代对象（通常是Promise数组），当所有Promise都变为fulfilled状态时，返回的Promise才会变为fulfilled，结果是一个包含所有Promise返回值的数组，顺序和传入的Promise顺序一致。如果其中有一个Promise变为rejected状态，返回的Promise会立即变为rejected，拒绝原因是第一个被拒绝的Promise的原因。

const p1 = Promise.resolve(1);
const p2 = new Promise(resolve => setTimeout(() => resolve(2), 1000));
const p3 = Promise.resolve(3);

Promise.all([p1, p2, p3]).then(res => {
  console.log(res); // 等待1秒后输出[1,2,3]
}).catch(err => {
  console.log(err);
});

// 有一个rejected的情况
const p4 = Promise.reject('错误');
Promise.all([p1, p4, p3]).catch(err => {
  console.log(err); // 输出错误
});

使用注意事项

• 如果传入的可迭代对象为空数组，Promise.all会立即返回一个fulfilled状态的Promise，结果为空数组
• 如果传入的数组中不是Promise对象，会被自动转换为Promise对象再处理

Promise.allSettled

Promise.allSettled同样接收一个可迭代的Promise集合，它会等待所有Promise都完成（不管是fulfilled还是rejected），然后返回一个Promise，结果是一个数组，每个元素对应每个Promise的结果，包含status字段表示状态，如果是fulfilled则有value字段，如果是rejected则有reason字段。

const p1 = Promise.resolve(1);
const p2 = Promise.reject('错误');
const p3 = new Promise(resolve => setTimeout(() => resolve(3), 500));

Promise.allSettled([p1, p2, p3]).then(res => {
  console.log(res);
  // 输出：
  // [
  //   { status: 'fulfilled', value: 1 },
  //   { status: 'rejected', reason: '错误' },
  //   { status: 'fulfilled', value: 3 }
  // ]
});

和Promise.all的区别是，它不会因为某个Promise被拒绝就提前结束，适合需要获取所有异步任务最终结果的场景，比如批量上传文件，不管单个文件是否上传成功都需要知道所有文件的上传结果。

Promise.race

Promise.race接收一个可迭代的Promise集合，返回的Promise会跟随第一个完成（不管是fulfilled还是rejected）的Promise的状态和结果，也就是谁先改变状态就用谁的结果。

const p1 = new Promise(resolve => setTimeout(() => resolve('p1完成'), 1000));
const p2 = new Promise(resolve => setTimeout(() => resolve('p2完成'), 500));
const p3 = Promise.reject('p3失败');

// p2先完成
Promise.race([p1, p2]).then(res => {
  console.log(res); // 输出p2完成
});

// p3先被拒绝
Promise.race([p1, p3]).catch(err => {
  console.log(err); // 输出p3失败
});

常见使用场景是给异步请求设置超时时间，比如下面是一个请求超时处理的示例：

function requestWithTimeout(url, timeout) {
  const requestPromise = fetch(url);
  const timeoutPromise = new Promise((_, reject) => {
    setTimeout(() => reject('请求超时'), timeout);
  });
  return Promise.race([requestPromise, timeoutPromise]);
}

// 假设请求地址，实际使用时替换成真实地址
requestWithTimeout('https://ipipp.com/api/test', 2000)
  .then(res => res.json())
  .catch(err => console.log(err));

Promise.any

Promise.any接收一个可迭代的Promise集合，当其中有一个Promise变为fulfilled状态时，返回的Promise就会变为fulfilled，结果就是第一个fulfilled的Promise的返回值。如果所有Promise都变为rejected状态，返回的Promise会变为rejected，拒绝原因是一个AggregateError对象，包含所有拒绝的原因。

const p1 = Promise.reject('错误1');
const p2 = new Promise(resolve => setTimeout(() => resolve('p2成功'), 500));
const p3 = Promise.reject('错误2');

Promise.any([p1, p2, p3]).then(res => {
  console.log(res); // 输出p2成功
}).catch(err => {
  console.log(err.errors); // 输出所有拒绝原因
});

// 所有都拒绝的情况
Promise.any([p1, p3]).catch(err => {
  console.log(err instanceof AggregateError); // 输出true
  console.log(err.errors); // 输出['错误1', '错误2']
});

和Promise.race的区别是，Promise.any只关心是否有成功的Promise，只要有一个成功就不会进入rejected状态，而Promise.race只要有一个先改变状态（不管成功还是失败）就会跟随那个状态。

方法对比总结

下面是几个常用静态方法的核心特性对比：

在实际开发中，我们可以根据具体的异步任务协作需求，选择合适的Promise静态方法，减少不必要的异步逻辑代码，让异步流程更清晰易维护。如果使用Promise.all时需要处理单个任务失败不影响整体的情况，可以提前给每个Promise添加catch处理，避免整个Promise.all被拒绝。

PromiseJavaScript异步编程静态方法修改时间：2026-06-29 13:39:56