JavaScript 中的 Promise 静态方法详解：Promise.allSettled 与 Promise.any 的区别、内部原理与应用场景

1. 问题背景

在异步编程中，Promise 提供了多种组合并行 Promise 的方法。除了常见的 Promise.all() 和 Promise.race() 之外，ES2020 和 ES2021 分别引入了 Promise.allSettled() 和 Promise.any() 这两个静态方法。它们解决了特定场景下的问题，但很多开发者容易混淆它们的行为差异。今天我们就深入探讨这两个方法。

2. 基本概念回顾

Promise.allSettled (ES2020)

• 功能：等待所有 Promise 完成（无论是成功还是失败），然后返回一个结果数组
• 结果：每个结果都是一个对象，包含 status 和 value/reason 属性
• 不会短路：即使有 Promise 被拒绝，也会等待所有 Promise 完成

Promise.any (ES2021)

• 功能：等待第一个成功的 Promise，如果所有 Promise 都失败，则返回一个特殊的错误
• 结果：返回第一个成功 Promise 的值
• 会短路：一旦有 Promise 成功，立即返回，不再等待其他 Promise

3. 详细工作原理

3.1 Promise.allSettled 的详细工作流程

// 示例场景
const p1 = Promise.resolve('成功1');
const p2 = Promise.reject('失败2');
const p3 = Promise.resolve('成功3');

Promise.allSettled([p1, p2, p3])
  .then(results => {
    console.log(results);
    // 输出:
    // [
    //   { status: 'fulfilled', value: '成功1' },
    //   { status: 'rejected', reason: '失败2' },
    //   { status: 'fulfilled', value: '成功3' }
    // ]
  });

内部实现机制：

1. 输入验证：首先检查传入的是否是可迭代对象
2. Promise包装：将每个元素转换为 Promise（使用 Promise.resolve() 包装）
3. 计数器初始化：设置一个计数器，跟踪未完成的 Promise 数量
4. 结果收集：创建一个与输入数组长度相同的结果数组
5. 监听所有 Promise：
   • 每个 Promise 完成后（无论成功失败），将结果格式化为标准对象
   • 成功：{ status: 'fulfilled', value: 结果值 }
   • 失败：{ status: 'rejected', reason: 错误原因 }
6. 完成判断：计数器减1，当计数器为0时，返回结果数组

关键特点：

• 总是返回一个包含所有结果的数组
• 永远不会被拒绝（除非传入参数不是可迭代对象）
• 结果顺序与输入顺序一致

3.2 Promise.any 的详细工作流程

// 示例1：至少有一个成功
const p1 = Promise.reject('错误1');
const p2 = Promise.resolve('成功2');
const p3 = Promise.reject('错误3');

Promise.any([p1, p2, p3])
  .then(result => {
    console.log(result); // 输出: "成功2"
  })
  .catch(error => {
    console.log(error); // 不会执行，因为p2成功了
  });

// 示例2：全部失败
const errors = [
  Promise.reject('错误A'),
  Promise.reject('错误B'),
  Promise.reject('错误C')
];

Promise.any(errors)
  .catch(error => {
    console.log(error.name); // "AggregateError"
    console.log(error.errors); // ["错误A", "错误B", "错误C"]
  });

内部实现机制：

1. 输入验证：检查传入的是否是可迭代对象
2. Promise包装：将每个元素转换为 Promise
3. 错误收集器：创建一个数组来收集所有错误（用于全部失败的情况）
4. 成功响应：
   • 监听每个 Promise
   • 当任意一个 Promise 成功时，立即用它的值完成返回的 Promise
   • 忽略其他未完成的 Promise（它们仍在后台运行）
5. 全部失败处理：
   • 记录每个 Promise 的拒绝原因
   • 当所有 Promise 都失败时，创建一个 AggregateError
   • 用这个 AggregateError 拒绝返回的 Promise

AggregateError 结构：

class AggregateError extends Error {
  constructor(errors, message) {
    super(message);
    this.name = 'AggregateError';
    this.errors = errors; // 包含所有错误信息的数组
  }
}

4. 核心区别对比表

5. 典型应用场景

Promise.allSettled 的应用场景：

1. 批量操作，需要完整报告

async function uploadMultipleFiles(files) {
  const uploadPromises = files.map(file => uploadFile(file));
  const results = await Promise.allSettled(uploadPromises);
  
  const successfulUploads = results
    .filter(r => r.status === 'fulfilled')
    .map(r => r.value);
    
  const failedUploads = results
    .filter(r => r.status === 'rejected')
    .map(r => r.reason);
    
  return { successfulUploads, failedUploads };
}

2. 表单多字段独立验证

async function validateForm(formData) {
  const validations = [
    validateEmail(formData.email),
    validatePassword(formData.password),
    validateUsername(formData.username)
  ];
  
  const results = await Promise.allSettled(validations);
  return results.map((result, i) => ({
    field: ['email', 'password', 'username'][i],
    valid: result.status === 'fulfilled',
    error: result.status === 'rejected' ? result.reason : null
  }));
}

Promise.any 的应用场景：

1. 多源数据获取（获取最快可用源）

async function fetchFromFastestSource() {
  const sources = [
    fetchFromPrimaryAPI(),
    fetchFromSecondaryAPI(),
    fetchFromCache()
  ];
  
  try {
    const data = await Promise.any(sources);
    return data;
  } catch (error) {
    console.error('所有数据源都失败了:', error.errors);
    throw new Error('无法获取数据');
  }
}

2. 冗余请求（提高可用性）

async function getServerTime() {
  const timeServers = [
    fetchTimeFrom('time.google.com'),
    fetchTimeFrom('time.apple.com'),
    fetchTimeFrom('time.windows.com')
  ];
  
  return Promise.any(timeServers);
}

3. 服务降级策略

async function getDataWithFallback() {
  const strategies = [
    fetchFromGraphQL().catch(() => Promise.reject('GraphQL失败')),
    fetchFromREST().catch(() => Promise.reject('REST失败')),
    fetchFromLegacyAPI().catch(() => Promise.reject('旧API失败')),
    getMockData()  // 兜底方案
  ];
  
  return Promise.any(strategies);
}

6. 手动实现示例（加深理解）

手动实现 Promise.allSettled：

Promise.myAllSettled = function(promises) {
  // 1. 参数验证
  if (!promises || typeof promises[Symbol.iterator] !== 'function') {
    return Promise.reject(new TypeError('参数必须是可迭代对象'));
  }
  
  return new Promise((resolve) => {
    const results = [];
    let completedCount = 0;
    const total = promises.length;
    
    // 处理空数组
    if (total === 0) {
      resolve(results);
      return;
    }
    
    promises.forEach((item, index) => {
      // 2. 包装为Promise
      Promise.resolve(item)
        .then(value => {
          results[index] = { status: 'fulfilled', value };
        })
        .catch(reason => {
          results[index] = { status: 'rejected', reason };
        })
        .finally(() => {
          completedCount++;
          // 3. 所有Promise都完成
          if (completedCount === total) {
            resolve(results);
          }
        });
    });
  });
};

手动实现 Promise.any：

Promise.myAny = function(promises) {
  // 1. 参数验证
  if (!promises || typeof promises[Symbol.iterator] !== 'function') {
    return Promise.reject(new TypeError('参数必须是可迭代对象'));
  }
  
  return new Promise((resolve, reject) => {
    const errors = [];
    let completedCount = 0;
    const total = promises.length;
    
    // 2. 处理空数组
    if (total === 0) {
      reject(new AggregateError([], 'All promises were rejected'));
      return;
    }
    
    promises.forEach((item, index) => {
      // 3. 包装为Promise
      Promise.resolve(item)
        .then(resolve)  // 4. 任意一个成功就立即解决
        .catch(error => {
          errors[index] = error;
          completedCount++;
          
          // 5. 全部失败
          if (completedCount === total) {
            reject(new AggregateError(errors, 'All promises were rejected'));
          }
        });
    });
  });
};

7. 注意事项和最佳实践

Promise.allSettled 的注意事项：

1. 内存使用：会存储所有结果，如果处理大量数据需要注意内存
2. 错误信息：错误被包装在结果对象中，不会触发 .catch()
3. 性能：必须等待最慢的 Promise 完成

// 正确使用
Promise.allSettled(promises)
  .then(results => {
    const successes = results.filter(r => r.status === 'fulfilled');
    const failures = results.filter(r => r.status === 'rejected');
    // 分别处理成功和失败
  });
  // 注意：这里不需要 .catch()，因为 allSettled 永远不会被拒绝

Promise.any 的注意事项：

1. 错误处理：必须处理 AggregateError
2. 资源泄漏：未完成的 Promise 仍在后台运行
3. 顺序忽略：不保证结果的顺序性

// 正确使用
Promise.any(promises)
  .then(firstSuccess => {
    // 处理第一个成功结果
  })
  .catch(error => {
    if (error instanceof AggregateError) {
      // 所有Promise都失败了
      console.error('所有尝试都失败了:', error.errors);
    } else {
      // 其他错误
      console.error('其他错误:', error);
    }
  });

8. 与其他Promise方法的对比

// 对比表格
const p1 = Promise.resolve('A');
const p2 = Promise.reject('B');
const p3 = Promise.resolve('C');

// Promise.all: 有一个失败就整体失败
Promise.all([p1, p2, p3])
  .then(console.log)  // 不会执行
  .catch(e => console.log('all error:', e));  // 输出: "B"

// Promise.race: 第一个完成（无论成功失败）
Promise.race([p1, p2, p3])
  .then(console.log)  // 输出: "A"
  .catch(e => console.log('race error:', e));  // 不会执行

// Promise.allSettled: 等待所有完成
Promise.allSettled([p1, p2, p3])
  .then(results => console.log('allSettled:', results));
  // 输出: [{status: "fulfilled", value: "A"}, ...]

// Promise.any: 第一个成功的
Promise.any([p1, p2, p3])
  .then(console.log)  // 输出: "A"
  .catch(e => console.log('any error:', e.errors));  // 不会执行

9. 实际工程应用

场景：用户行为分析（上报所有数据，不因单点失败而中断）

class AnalyticsTracker {
  async trackEvents(events) {
    const trackingPromises = events.map(event => 
      this.sendToAnalyticsService(event)
        .catch(error => {
          // 记录错误但继续执行
          console.warn(`分析事件 ${event.type} 上报失败:`, error);
          throw error; // 抛出以便 allSettled 能捕获
        })
    );
    
    const results = await Promise.allSettled(trackingPromises);
    
    // 生成报告
    const report = {
      total: events.length,
      succeeded: results.filter(r => r.status === 'fulfilled').length,
      failed: results.filter(r => r.status === 'rejected').length,
      failures: results
        .filter(r => r.status === 'rejected')
        .map(r => ({
          reason: r.reason.message,
          timestamp: new Date().toISOString()
        }))
    };
    
    return report;
  }
}

场景：多CDN回源（使用最快的可用CDN）

class ContentFetcher {
  constructor(cdnUrls) {
    this.cdnUrls = cdnUrls;
  }
  
  async fetchContent(path, timeout = 5000) {
    const fetchWithTimeout = (url) => {
      const controller = new AbortController();
      const timeoutId = setTimeout(() => controller.abort(), timeout);
      
      return fetch(`${url}/${path}`, { signal: controller.signal })
        .then(response => {
          clearTimeout(timeoutId);
          if (!response.ok) throw new Error(`HTTP ${response.status}`);
          return response.json();
        })
        .catch(error => {
          clearTimeout(timeoutId);
          return Promise.reject(error);
        });
    };
    
    const promises = this.cdnUrls.map(url => 
      fetchWithTimeout(url)
        .catch(error => 
          Promise.reject({ url, error: error.message })
        )
    );
    
    try {
      return await Promise.any(promises);
    } catch (error) {
      if (error instanceof AggregateError) {
        throw new Error(
          `所有CDN都失败:\n${error.errors.map(e => 
            `${e.url}: ${e.error}`
          ).join('\n')}`
        );
      }
      throw error;
    }
  }
}

10. 总结要点

1. Promise.allSettled 适用于需要知道所有异步操作最终结果的场景，特别是当部分失败不应阻止其他操作时
2. Promise.any 适用于获取最快可用结果的场景，如多源数据获取、服务降级
3. 两者都不会被传入的 Promise 拒绝（除了 Promise.any 在所有输入都失败时返回 AggregateError）
4. 理解它们的底层实现有助于在复杂场景中正确选择使用
5. 在实际工程中，结合使用这些方法可以构建更健壮的异步系统

这两个方法解决了不同的问题场景，正确选择和使用它们可以显著提高代码的健壮性和用户体验。记住：allSettled 关注"完整报告"，any 关注"最快成功"。