Node.js中Promise.allSettled的深度解析与实战应用

1. Node.js中Promise.allSettled的深度解析与实战应用

在现代Web开发中，异步操作处理是每个Node.js开发者必须掌握的核心技能。随着应用复杂度的提升，我们经常需要同时处理多个异步请求，这时候Promise.allSettled就成为了一个不可或缺的工具。本文将深入探讨这个强大的API，从底层原理到实际应用场景，再到性能优化技巧，为你全面解析如何利用Promise.allSettled构建更健壮的Node.js应用。

1.1 Promise.allSettled的核心价值

Promise.allSettled是ES2020引入的新特性，它解决了传统Promise.all在处理并行请求时的一个关键痛点：当其中任何一个Promise被拒绝(reject)时，整个操作就会立即失败。这种"全有或全无"的特性在很多实际业务场景中并不适用。

想象一下电商网站的商品详情页需要同时获取：

• 商品基本信息
• 库存状态
• 用户评价
• 推荐商品

如果使用Promise.all，当用户评价服务暂时不可用时，整个页面都无法加载，即使用户最关心的商品信息和库存状态已经成功获取。这就是Promise.allSettled大显身手的地方 - 它能确保所有请求都能执行完成，无论成功与否，然后让我们根据每个请求的实际状态来决定如何处理。

1.2 与Promise.all的对比分析

让我们通过一个技术对比表来清晰理解两者的区别：

javascript复制// Promise.all示例 - 任何一个失败都会导致整个操作失败
const [user, orders] = await Promise.all([
  fetchUser(),
  fetchOrders() // 如果这个失败，整个操作就失败
]);

// Promise.allSettled示例 - 所有请求都会完成
const results = await Promise.allSettled([
  fetchUser(),
  fetchOrders() // 即使这个失败，我们仍然能处理用户数据
]);
const user = results[0].status === 'fulfilled' ? results[0].value : null;
const orders = results[1].status === 'fulfilled' ? results[1].value : [];

1.3 底层实现原理

理解Promise.allSettled的底层实现有助于我们更好地使用它。本质上，它做了以下几件事：

1. 接收一个Promise数组作为输入
2. 为每个Promise添加状态跟踪
3. 等待所有Promise完成（无论是fulfilled还是rejected）
4. 返回一个结果数组，每个元素包含：
   • status: "fulfilled"或"rejected"
   • value: 成功时的值（仅当status为fulfilled）
   • reason: 失败时的原因（仅当status为rejected）

Node.js的事件循环机制使得这些Promise能够真正并行执行，充分利用系统资源。当使用Promise.allSettled时，所有的I/O操作（如网络请求）都会被同时发起，然后等待它们全部完成。

2. 实战应用场景与最佳实践

2.1 电商平台数据聚合

电商平台是Promise.allSettled的典型应用场景。让我们看一个更完整的示例：

javascript复制async function getProductPageData(productId) {
  const [
    productInfo,
    inventory,
    reviews,
    recommendations
  ] = await Promise.allSettled([
    fetchProductInfo(productId),
    fetchInventory(productId),
    fetchReviews(productId),
    fetchRecommendations(productId)
  ]);

  return {
    product: productInfo.status === 'fulfilled' ? productInfo.value : null,
    stock: inventory.status === 'fulfilled' ? inventory.value : { available: false },
    reviews: reviews.status === 'fulfilled' ? reviews.value : [],
    recommendedItems: recommendations.status === 'fulfilled' ? recommendations.value : getDefaultRecommendations()
  };
}

这种模式确保了即使某些服务暂时不可用，页面仍然可以显示核心内容，只是某些部分会显示降级内容或占位符，而不是整个页面崩溃。

2.2 微服务架构中的容错处理

在微服务架构中，服务间调用频繁，Promise.allSettled可以帮助我们构建更具弹性的系统：

javascript复制async function aggregateUserData(userId) {
  const services = [
    'profile',
    'orders',
    'preferences',
    'notifications'
  ];

  const requests = services.map(service => 
    callService(service, userId)
      .then(data => ({ service, data }))
      .catch(error => ({ service, error }))
  );

  const results = await Promise.allSettled(requests);

  const successful = results
    .filter(r => r.status === 'fulfilled')
    .map(r => r.value)
    .filter(r => !r.error);

  const failed = results
    .filter(r => r.status === 'fulfilled')
    .map(r => r.value)
    .filter(r => r.error);

  // 记录失败的服务以便后续处理
  if (failed.length > 0) {
    logFailedServices(failed);
  }

  // 构建响应对象，合并成功的数据
  return successful.reduce((acc, curr) => {
    acc[curr.service] = curr.data;
    return acc;
  }, {});
}

这种模式不仅确保了部分失败不会导致整个操作失败，还能清晰地知道哪些服务调用失败了，便于后续的监控和修复。

2.3 批量数据处理

当需要处理大量数据时，Promise.allSettled可以帮助我们有效地并行处理：

javascript复制async function processBatchRecords(records) {
  const BATCH_SIZE = 10;
  const batches = [];
  
  for (let i = 0; i < records.length; i += BATCH_SIZE) {
    batches.push(records.slice(i, i + BATCH_SIZE));
  }

  for (const batch of batches) {
    const promises = batch.map(record => 
      processRecord(record)
        .then(result => ({ success: true, result }))
        .catch(error => ({ success: false, error }))
    );

    const results = await Promise.allSettled(promises);
    
    const successful = results
      .filter(r => r.status === 'fulfilled')
      .map(r => r.value)
      .filter(r => r.success);

    const failed = results
      .filter(r => r.status === 'fulfilled')
      .map(r => r.value)
      .filter(r => !r.success);

    // 处理成功和失败的记录
    handleSuccessfulRecords(successful);
    handleFailedRecords(failed);
    
    // 避免过快的请求速率
    await new Promise(resolve => setTimeout(resolve, 100));
  }
}

3. 高级技巧与性能优化

3.1 结合超时控制

为了防止某些请求耗时过长，我们可以结合Promise.race实现超时控制：

javascript复制function withTimeout(promise, timeoutMs) {
  const timeout = new Promise((_, reject) => 
    setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs)
  );
  
  return Promise.race([promise, timeout]);
}

async function fetchWithFallback(url, fallbackData, timeout = 3000) {
  try {
    const response = await withTimeout(fetch(url), timeout);
    return await response.json();
  } catch (error) {
    console.warn(`Failed to fetch ${url}:`, error.message);
    return fallbackData;
  }
}

async function getPageData() {
  const results = await Promise.allSettled([
    fetchWithFallback('/api/user', { name: 'Guest' }),
    fetchWithFallback('/api/posts', []),
    fetchWithFallback('/api/stats', { views: 0 })
  ]);
  
  return results.map(result => 
    result.status === 'fulfilled' ? result.value : null
  );
}

3.2 限制并发数

当需要处理大量请求时，直接使用Promise.allSettled可能会导致系统资源耗尽。我们可以实现一个并发控制函数：

javascript复制class PromisePool {
  constructor(maxConcurrent) {
    this.maxConcurrent = maxConcurrent;
    this.queue = [];
    this.active = 0;
  }

  add(promiseFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({
        promiseFn,
        resolve,
        reject
      });
      this.next();
    });
  }

  next() {
    if (this.active >= this.maxConcurrent || !this.queue.length) return;

    this.active++;
    const { promiseFn, resolve, reject } = this.queue.shift();
    
    promiseFn()
      .then(resolve)
      .catch(reject)
      .finally(() => {
        this.active--;
        this.next();
      });
  }
}

async function processUrls(urls, concurrency = 5) {
  const pool = new PromisePool(concurrency);
  const results = await Promise.allSettled(
    urls.map(url => pool.add(() => fetch(url)))
  );
  
  return results.map(result => 
    result.status === 'fulfilled' ? result.value : null
  );
}

3.3 错误分类处理

在实际应用中，我们可以根据错误类型采取不同的处理策略：

javascript复制async function handleMultipleRequests(requests) {
  const results = await Promise.allSettled(requests);
  
  const categorized = {
    success: [],
    networkErrors: [],
    validationErrors: [],
    serverErrors: [],
    timeouts: [],
    unknownErrors: []
  };

  for (const result of results) {
    if (result.status === 'fulfilled') {
      categorized.success.push(result.value);
      continue;
    }
    
    const error = result.reason;
    if (error instanceof NetworkError) {
      categorized.networkErrors.push(error);
    } else if (error instanceof ValidationError) {
      categorized.validationErrors.push(error);
    } else if (error.code === 500) {
      categorized.serverErrors.push(error);
    } else if (error.message.includes('timeout')) {
      categorized.timeouts.push(error);
    } else {
      categorized.unknownErrors.push(error);
    }
  }

  // 根据错误类型采取不同措施
  if (categorized.timeouts.length > 0) {
    retryRequests(categorized.timeouts);
  }
  
  if (categorized.networkErrors.length > 0) {
    alertNetworkIssues(categorized.networkErrors);
  }

  return {
    data: categorized.success,
    errors: {
      ...categorized,
      success: undefined
    }
  };
}

4. 常见问题与解决方案

4.1 内存使用优化

当处理大量Promise时，内存管理变得很重要。以下是一些优化技巧：

1. 分批处理：不要一次性发起太多请求，可以分成小批次处理
2. 流式处理：对于大数据集，考虑使用流式处理而不是全部加载到内存
3. 及时清理：处理完的结果及时释放引用

javascript复制async function processLargeDataset(dataset, batchSize = 100) {
  const results = [];
  
  for (let i = 0; i < dataset.length; i += batchSize) {
    const batch = dataset.slice(i, i + batchSize);
    const batchResults = await Promise.allSettled(
      batch.map(processItem)
    );
    
    // 处理并立即存储结果，释放内存
    const processed = processBatchResults(batchResults);
    results.push(...processed);
    
    // 手动触发垃圾回收（谨慎使用）
    if (global.gc) global.gc();
  }
  
  return results;
}

4.2 调试技巧

调试并行请求可能比较困难，以下是一些有用的技巧：

1. 添加请求标识：为每个请求添加唯一ID便于跟踪
2. 记录时间戳：记录每个请求的开始和结束时间
3. 可视化日志：使用工具将并行请求可视化

javascript复制async function debugParallelRequests(urls) {
  const requests = urls.map((url, index) => {
    const start = Date.now();
    return fetch(url)
      .then(response => {
        const end = Date.now();
        return {
          id: index,
          url,
          status: 'success',
          duration: end - start,
          data: response
        };
      })
      .catch(error => {
        const end = Date.now();
        return {
          id: index,
          url,
          status: 'error',
          duration: end - start,
          error: error.message
        };
      });
  });

  const results = await Promise.allSettled(requests);
  
  console.table(results.map(r => ({
    ...r.value,
    promiseStatus: r.status
  })));
}

4.3 测试策略

测试Promise.allSettled的行为需要特别考虑各种成功和失败的组合：

javascript复制describe('Promise.allSettled', () => {
  it('should handle mixed success and failure', async () => {
    const success = Promise.resolve('ok');
    const failure = Promise.reject(new Error('failed'));
    
    const results = await Promise.allSettled([success, failure]);
    
    expect(results).toEqual([
      { status: 'fulfilled', value: 'ok' },
      { status: 'rejected', reason: expect.any(Error) }
    ]);
  });

  it('should preserve order of results', async () => {
    const fast = new Promise(resolve => setTimeout(() => resolve(1), 100));
    const slow = new Promise(resolve => setTimeout(() => resolve(2), 200));
    
    const results = await Promise.allSettled([fast, slow]);
    
    expect(results[0].value).toBe(1);
    expect(results[1].value).toBe(2);
  });
});

5. 与其他异步模式的结合

5.1 与async/await的结合

Promise.allSettled可以很好地与async/await语法结合，使代码更清晰：

javascript复制async function fetchMultipleResources(resources) {
  const results = await Promise.allSettled(
    resources.map(resource => fetchResource(resource))
  );

  const data = [];
  const errors = [];

  for (const result of results) {
    if (result.status === 'fulfilled') {
      data.push(result.value);
    } else {
      errors.push(result.reason);
    }
  }

  return { data, errors };
}

5.2 与异步迭代器的结合

Node.js 10+支持异步迭代器，可以与Promise.allSettled结合使用：

javascript复制async function* processInBatches(items, batchSize, processFn) {
  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    const results = await Promise.allSettled(batch.map(processFn));
    
    yield results.map(r => 
      r.status === 'fulfilled' ? r.value : null
    );
  }
}

// 使用示例
async function handleLargeDataset() {
  const dataset = [...]; // 大型数据集
  const processor = processInBatches(dataset, 10, processItem);
  
  for await (const batchResults of processor) {
    // 处理每批结果
    storeResults(batchResults);
  }
}

5.3 与事件发射器的结合

在某些场景下，我们可以将Promise.allSettled与事件发射器结合，实现更灵活的异步控制：

javascript复制const { EventEmitter } = require('events');

class BatchProcessor extends EventEmitter {
  constructor(concurrency = 5) {
    super();
    this.concurrency = concurrency;
    this.queue = [];
    this.active = 0;
  }

  add(task) {
    return new Promise((resolve, reject) => {
      this.queue.push({ task, resolve, reject });
      this.processNext();
    });
  }

  processNext() {
    if (this.active >= this.concurrency || !this.queue.length) return;

    this.active++;
    const { task, resolve, reject } = this.queue.shift();
    
    this.emit('task:start', task);
    
    Promise.resolve(task())
      .then(result => {
        this.emit('task:success', result);
        resolve(result);
      })
      .catch(error => {
        this.emit('task:error', error);
        reject(error);
      })
      .finally(() => {
        this.active--;
        this.processNext();
      });
  }

  async processAll(tasks) {
    const results = await Promise.allSettled(tasks.map(task => this.add(task)));
    
    this.emit('batch:complete', results);
    
    return results.map(result => 
      result.status === 'fulfilled' ? result.value : null
    );
  }
}

// 使用示例
const processor = new BatchProcessor(3);

processor
  .on('task:start', task => console.log('Task started:', task))
  .on('task:success', result => console.log('Task succeeded:', result))
  .on('task:error', error => console.error('Task failed:', error))
  .on('batch:complete', () => console.log('All tasks completed'));

const tasks = [...]; // 任务数组
processor.processAll(tasks);

6. 实际项目中的经验分享

6.1 监控与指标收集

在生产环境中使用Promise.allSettled时，添加适当的监控非常重要：

javascript复制async function monitoredAllSettled(promises, metricName) {
  const start = Date.now();
  const results = await Promise.allSettled(promises);
  const duration = Date.now() - start;
  
  // 记录性能指标
  recordMetric(`${metricName}.duration`, duration);
  recordMetric(`${metricName}.count`, promises.length);
  
  const successCount = results.filter(r => r.status === 'fulfilled').length;
  const failureCount = results.length - successCount;
  
  recordMetric(`${metricName}.success`, successCount);
  recordMetric(`${metricName}.failure`, failureCount);
  
  // 记录失败原因
  results
    .filter(r => r.status === 'rejected')
    .forEach(r => {
      logError(r.reason);
    });
  
  return results;
}

// 使用示例
async function fetchDashboardData() {
  return monitoredAllSettled([
    fetchUserData(),
    fetchAnalytics(),
    fetchNotifications()
  ], 'dashboard.data_fetch');
}

6.2 重试策略

对于失败的请求，合理的重试策略可以大大提高系统可靠性：

javascript复制async function withRetry(fn, maxRetries = 3, delayMs = 1000) {
  let lastError;
  
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error;
      if (i < maxRetries - 1) {
        await new Promise(resolve => setTimeout(resolve, delayMs * (i + 1)));
      }
    }
  }
  
  throw lastError;
}

async function fetchWithFallbackAndRetry(url, fallbackData) {
  try {
    return await withRetry(() => fetch(url), 2);
  } catch (error) {
    console.error(`Failed to fetch ${url} after retries:`, error);
    return fallbackData;
  }
}

async function getCriticalData() {
  const results = await Promise.allSettled([
    fetchWithFallbackAndRetry('/api/primary', null),
    fetchWithFallbackAndRetry('/api/secondary', []),
    fetchWithFallbackAndRetry('/api/tertiary', {})
  ]);
  
  return results.map(result => 
    result.status === 'fulfilled' ? result.value : null
  );
}

6.3 缓存集成

结合缓存可以进一步提高性能并减少失败：

javascript复制class CachedFetcher {
  constructor(cacheTTL = 300000) { // 5分钟缓存
    this.cache = new Map();
    this.cacheTTL = cacheTTL;
  }
  
  async fetch(url) {
    const cached = this.cache.get(url);
    
    if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
      return cached.data;
    }
    
    try {
      const response = await fetch(url);
      const data = await response.json();
      
      this.cache.set(url, {
        data,
        timestamp: Date.now()
      });
      
      return data;
    } catch (error) {
      // 如果请求失败但缓存中有旧数据，返回旧数据
      if (cached) {
        console.warn(`Using cached data for ${url} due to fetch error`);
        return cached.data;
      }
      throw error;
    }
  }
  
  async fetchAll(urls) {
    const results = await Promise.allSettled(
      urls.map(url => this.fetch(url))
    );
    
    return results.map(result => 
      result.status === 'fulfilled' ? result.value : null
    );
  }
}

// 使用示例
const fetcher = new CachedFetcher();
const data = await fetcher.fetchAll([
  '/api/products',
  '/api/users',
  '/api/stats'
]);

7. 性能考量与基准测试

7.1 与Promise.all的性能对比

让我们通过实际测试来比较Promise.allSettled和Promise.all的性能差异：

javascript复制async function runBenchmark() {
  const testCases = [
    { size: 10, failureRate: 0 },
    { size: 10, failureRate: 0.1 },
    { size: 100, failureRate: 0 },
    { size: 100, failureRate: 0.1 },
    { size: 1000, failureRate: 0 },
    { size: 1000, failureRate: 0.1 }
  ];
  
  const results = [];
  
  for (const { size, failureRate } of testCases) {
    // 准备测试数据
    const promises = Array.from({ length: size }, (_, i) => {
      return i < size * failureRate 
        ? Promise.reject(new Error(`Simulated failure ${i}`))
        : Promise.resolve(`Success ${i}`);
    });
    
    // 测试Promise.all
    const allStart = Date.now();
    try {
      await Promise.all(promises);
    } catch (e) {
      // 忽略错误
    }
    const allDuration = Date.now() - allStart;
    
    // 测试Promise.allSettled
    const allSettledStart = Date.now();
    await Promise.allSettled(promises);
    const allSettledDuration = Date.now() - allSettledStart;
    
    results.push({
      size,
      failureRate,
      allDuration,
      allSettledDuration,
      difference: allSettledDuration - allDuration
    });
  }
  
  console.table(results);
}

runBenchmark();

典型测试结果可能如下（单位：毫秒）：

从测试结果可以看出，Promise.allSettled的性能开销非常小，即使在高失败率情况下，额外的开销通常也不超过5%。这种微小的性能代价换来的可靠性提升是非常值得的。

7.2 内存使用分析

Promise.allSettled由于需要存储额外的状态信息，确实会比Promise.all使用更多内存。让我们分析一下内存差异：

javascript复制function measureMemory(promiseCount) {
  const promises = Array.from({ length: promiseCount }, (_, i) => 
    i % 10 === 0 
      ? Promise.reject(new Error(`Error ${i}`))
      : Promise.resolve(i)
  );
  
  // 测量Promise.all的内存使用
  const allStart = process.memoryUsage().heapUsed;
  Promise.all(promises).catch(() => {});
  const allEnd = process.memoryUsage().heapUsed;
  const allMemory = allEnd - allStart;
  
  // 测量Promise.allSettled的内存使用
  const settledStart = process.memoryUsage().heapUsed;
  Promise.allSettled(promises);
  const settledEnd = process.memoryUsage().heapUsed;
  const settledMemory = settledEnd - settledStart;
  
  return {
    promiseCount,
    allMemory,
    settledMemory,
    difference: settledMemory - allMemory,
    differencePercentage: ((settledMemory - allMemory) / allMemory * 100).toFixed(2) + '%'
  };
}

// 测试不同规模的Promise数组
const testSizes = [10, 100, 1000, 10000];
const memoryResults = testSizes.map(measureMemory);

console.table(memoryResults);

测试结果可能如下（单位：字节）：

从内存测试可以看出，Promise.allSettled的内存开销确实比Promise.all高约20-25%，这是因为需要存储额外的状态信息。然而，对于大多数应用场景来说，这种内存开销的增加是可以接受的，特别是考虑到它带来的可靠性提升。

7.3 大规模并行处理的优化建议

当需要处理非常大量的并行请求时（如超过10000个），可以考虑以下优化策略：

1. 分批处理：将大任务分成小批次处理，每批适当大小（如100-1000个）
2. 流式处理：使用异步迭代器处理结果，而不是一次性收集所有结果
3. 内存监控：在处理过程中监控内存使用，必要时手动触发垃圾回收
4. 并发控制：限制同时进行的请求数量，避免系统资源耗尽

javascript复制async function processHugeDataset(dataset, batchSize = 100) {
  const results = [];
  
  for (let i = 0; i < dataset.length; i += batchSize) {
    const batch = dataset.slice(i, i + batchSize);
    
    // 处理当前批次
    const batchResults = await Promise.allSettled(
      batch.map(processItem)
    );
    
    // 立即处理结果并释放内存
    const processed = processBatchResults(batchResults);
    results.push(...processed);
    
    // 手动触发垃圾回收（谨慎使用）
    if (global.gc) {
      global.gc();
    }
    
    // 报告进度
    console.log(`Processed ${Math.min(i + batchSize, dataset.length)}/${dataset.length}`);
  }
  
  return results;
}

8. 安全性与错误处理的最佳实践

8.1 防止未处理的Promise拒绝

虽然Promise.allSettled本身不会导致未处理的拒绝，但在使用时仍需注意：

javascript复制// 不安全的用法 - 如果fetchUser()或fetchPosts()中有未捕获的错误
const [user, posts] = await Promise.allSettled([
  fetchUser(),    // 如果这个函数内部有未捕获的错误
  fetchPosts()    // 或者这个函数有未捕获的错误
]);

// 更安全的用法 - 确保每个Promise都有错误处理
const [user, posts] = await Promise.allSettled([
  fetchUser().catch(e => ({ error: e })),
  fetchPosts().catch(e => ({ error: e }))
]);

8.2 敏感数据处理

当处理敏感数据时，确保错误信息中不泄露敏感信息：

javascript复制async function fetchSecureData(resourceIds) {
  const results = await Promise.allSettled(
    resourceIds.map(id => 
      fetchSecureResource(id)
        .catch(error => {
          // 不泄露具体资源ID或敏感错误详情
          logError(`Failed to fetch secure resource: ${error.message}`);
          throw new Error('Failed to fetch secure data');
        })
    )
  );
  
  return results.map(result => {
    if (result.status === 'fulfilled') {
      return result.value;
    } else {
      // 返回通用的错误信息
      return { error: 'Data unavailable' };
    }
  });
}

8.3 超时与资源清理

对于可能长时间运行的请求，添加超时和资源清理逻辑：

javascript复制async function fetchWithTimeout(url, options = {}) {
  const { timeout = 5000, ...fetchOptions } = options;
  
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeout);
  
  try {
    const response = await fetch(url, {
      ...fetchOptions,
      signal: controller.signal
    });
    
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    
    return await response.json();
  } catch (error) {
    if (error.name === 'AbortError') {
      throw new Error(`Request timed out after ${timeout}ms`);
    }
    throw error;
  } finally {
    clearTimeout(timeoutId);
  }
}

async function fetchMultipleWithTimeouts(urls) {
  const results = await Promise.allSettled(
    urls.map(url => fetchWithTimeout(url))
  );
  
  return results.map(result => {
    if (result.status === 'fulfilled') {
      return result.value;
    } else {
      console.error('Fetch error:', result.reason.message);
      return null;
    }
  });
}

9. 与其他语言/环境的对比

9.1 与其他JavaScript环境的比较

Promise.allSettled的行为在不同JavaScript环境中基本一致，但有一些细微差别：

9.2 与其他编程语言的类似功能

许多其他编程语言也有类似的并发处理机制：

例如，Python中的等价实现：

python复制import asyncio

async def fetch_all():
    tasks = [
        fetch_url('url1'),
        fetch_url('url2'),
        fetch_url('url3')
    ]
    return await asyncio.gather(*tasks, return_exceptions=True)

# 使用示例
results = await fetch_all()
for result in results:
    if isinstance(result, Exception):
        print(f"Failed: {result}")
    else:
        print(f"Success: {result}")

9.3 在TypeScript中的使用

在TypeScript中使用Promise.allSettled可以获得更好的类型安全：

typescript复制interface Result<T> {
  status: 'fulfilled' | 'rejected';
  value?: T;
  reason?: any;
}

async function fetchAll<T>(promises: Promise<T>[]): Promise<Result<T>[]> {
  return Promise.allSettled(promises) as Promise<Result<T>[]>;
}

// 使用示例
async function example() {
  const results = await fetchAll<string>([
    Promise.resolve('success'),
    Promise.reject(new Error('failure'))
  ]);
  
  results.forEach(result => {
    if (result.status === 'fulfilled') {
      console.log('Success:', result.value);
    } else {
      console.error('Failed:', result.reason);
    }
  });
}

10. 总结与最佳实践建议

经过对Promise.allSettled的全面探讨，我们可以总结出以下最佳实践：

1. 优先考虑可靠性：在大多数业务场景中，Promise.allSettled提供的可靠性优势远超过其微小的性能开销。

2. 合理处理部分失败：设计系统时考虑部分失败的情况，确保即使某些操作失败，系统仍能提供降级服务。

3. 清晰的错误分类：对成功和失败的结果进行明确分类和处理，避免忽略错误。

4. 适当的性能优化：对于大规模并行处理，采用分批处理、并发控制等策略优化性能。

5. 全面的监控：添加适当的监控和日志，跟踪并行请求的成功率和性能。

6. 结合其他异步模式：根据需求将Promise.allSettled与超时控制、重试策略、缓存等模式结合使用。

7. 类型安全：在TypeScript项目中，使用适当的类型定义增强代码的可靠性。

8. 内存管理：处理大量Promise时注意内存使用，必要时进行分批处理。

9. 测试覆盖：确保测试覆盖各种成功和失败的组合情况。

10. 文档清晰：在团队文档中明确记录并行处理的策略和预期行为。

Promise.allSettled是现代JavaScript异步编程中一个极其强大的工具，它改变了我们处理并行操作的方式。通过合理使用这个API，我们可以构建出更健壮、更可靠的应用程序，为用户提供更好的体验。