Promise的静态方法

ECMAScript 6 引入了 Promise 作为异步编程的核心解决方案，其静态方法为处理异步操作提供了更灵活的方式。这些方法包括 Promise.resolve、Promise.reject、Promise.all、Promise.race、Promise.allSettled 和 Promise.any，每种方法针对不同的场景设计。

Promise.resolve

Promise.resolve 创建一个立即解析的 Promise 对象，其值为传入的参数。如果参数本身是一个 Promise，则直接返回该 Promise。

const resolvedPromise = Promise.resolve('立即解析的值');
resolvedPromise.then(value => {
  console.log(value); // 输出: '立即解析的值'
});

const existingPromise = new Promise(resolve => setTimeout(() => resolve('原始Promise'), 1000));
const wrappedPromise = Promise.resolve(existingPromise);
wrappedPromise.then(value => {
  console.log(value); // 1秒后输出: '原始Promise'
});

当需要将非 Promise 值转换为 Promise 时，Promise.resolve 非常有用。例如，在函数可能返回同步值或 Promise 的情况下：

function fetchData(maybeAsync) {
  return Promise.resolve(maybeAsync).then(data => {
    console.log('处理数据:', data);
  });
}

fetchData(42); // 同步值
fetchData(Promise.resolve('异步值')); // Promise

Promise.reject

Promise.reject 创建一个立即拒绝的 Promise 对象，其拒绝原因为传入的参数。

const rejectedPromise = Promise.reject(new Error('操作失败'));
rejectedPromise.catch(error => {
  console.error(error.message); // 输出: '操作失败'
});

在需要明确表示异步操作失败时，可以直接使用 Promise.reject：

function validateInput(input) {
  if (!input) {
    return Promise.reject(new Error('输入不能为空'));
  }
  return processInput(input);
}

Promise.all

Promise.all 接收一个 Promise 可迭代对象，当所有 Promise 都成功解析时返回一个包含所有结果的数组；如果任意一个 Promise 被拒绝，则立即拒绝。

const promise1 = Promise.resolve(1);
const promise2 = new Promise(resolve => setTimeout(() => resolve(2), 1000));
const promise3 = 3; // 非Promise值会被Promise.resolve转换

Promise.all([promise1, promise2, promise3])
  .then(values => {
    console.log(values); // 约1秒后输出: [1, 2, 3]
  })
  .catch(error => {
    console.error('其中一个失败:', error);
  });

典型应用场景是并行执行多个独立异步操作：

function fetchUserData() {
  return Promise.all([
    fetch('/api/user'),
    fetch('/api/user/settings'),
    fetch('/api/user/friends')
  ]).then(([user, settings, friends]) => {
    return { user, settings, friends };
  });
}

如果其中一个请求失败，整个 Promise.all 会立即终止：

Promise.all([
  Promise.resolve('成功1'),
  Promise.reject(new Error('失败')),
  Promise.resolve('成功2')
]).catch(error => {
  console.error(error.message); // 输出: '失败'
});

Promise.race

Promise.race 接收一个 Promise 可迭代对象，返回第一个敲定的 Promise（无论解决还是拒绝）。

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

Promise.race([fastPromise, slowPromise])
  .then(value => {
    console.log(value); // 约100毫秒后输出: '快'
  });

实际应用中可用于设置超时控制：

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

const apiCall = fetch('/api/data');
withTimeout(apiCall, 3000)
  .then(data => console.log('成功获取数据'))
  .catch(error => console.error(error.message)); // 3秒内未完成则报超时

Promise.allSettled

Promise.allSettled 等待所有 Promise 敲定（无论成功或失败），返回一个包含每个 Promise 结果的对象数组。

const promises = [
  Promise.resolve('成功'),
  Promise.reject(new Error('失败')),
  new Promise(resolve => setTimeout(() => resolve('延迟成功'), 1000))
];

Promise.allSettled(promises)
  .then(results => {
    results.forEach(result => {
      if (result.status === 'fulfilled') {
        console.log('成功:', result.value);
      } else {
        console.error('失败:', result.reason.message);
      }
    });
  });
/* 输出:
   成功: 成功
   失败: 失败
   成功: 延迟成功 (约1秒后)
*/

当需要确保所有操作都完成后再处理结果时特别有用：

async function logOperationResults(operations) {
  const results = await Promise.allSettled(operations);
  const report = results.map(result => 
    result.status === 'fulfilled' 
      ? { status: 'success', data: result.value }
      : { status: 'error', error: result.reason }
  );
  saveToDatabase(report);
}

Promise.any

Promise.any 接收一个 Promise 可迭代对象，返回第一个成功解析的 Promise。如果所有 Promise 都被拒绝，则抛出一个 AggregateError。

const server1 = new Promise((_, reject) => 
  setTimeout(() => reject(new Error('服务器1宕机')), 200)
);
const server2 = new Promise(resolve => 
  setTimeout(() => resolve('服务器2响应'), 100)
);
const server3 = new Promise((_, reject) => 
  setTimeout(() => reject(new Error('服务器3超时')), 300)
);

Promise.any([server1, server2, server3])
  .then(firstResponse => {
    console.log('使用响应:', firstResponse); // 约100毫秒后输出: '服务器2响应'
  })
  .catch(error => {
    console.error('所有服务器都失败:', error.errors);
  });

当有多个备用方案时，Promise.any 可以实现快速优先选择：

function fetchFromFastestMirror(mirrors) {
  return Promise.any(mirrors.map(url => 
    fetch(url).then(response => {
      if (!response.ok) throw new Error(`HTTP错误: ${response.status}`);
      return response.json();
    })
  )).then(data => {
    console.log('从最快镜像获取数据:', data);
    return data;
  });
}

如果所有 Promise 都失败，会收集所有错误：

Promise.any([
  Promise.reject(new Error('错误1')),
  Promise.reject(new Error('错误2'))
]).catch(error => {
  console.error('全部失败:');
  error.errors.forEach(e => console.log('-', e.message));
});
/* 输出:
   全部失败:
   - 错误1
   - 错误2
*/