18.1 Promise Combinators

Overview

Promise combinators are static methods on the Promise constructor that work with multiple promises. They enable parallel execution and provide different strategies for handling multiple async operations.

Promise.all()

┌─────────────────────────────────────────────────────────────────────────┐
│                         Promise.all()                                   │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  Promise.all([promise1, promise2, promise3])                            │
│                                                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐                                  │
│  │ Fetch A │  │ Fetch B │  │ Fetch C │  ← Parallel execution            │
│  └────┬────┘  └────┬────┘  └────┬────┘                                  │
│       │            │            │                                       │
│       ▼            ▼            ▼                                       │
│  ┌──────────────────────────────────────┐                               │
│  │          Wait for ALL                 │                              │
│  └──────────────────────────────────────┘                               │
│       │                                                                 │
│       ▼                                                                 │
│  [resultA, resultB, resultC]  ← Order preserved!                        │
│                                                                         │
│  ⚠️  If ANY promise rejects, the whole Promise.all rejects              │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Behavior

Use Cases

• •Fetching multiple resources simultaneously
• •Waiting for multiple independent operations
• •Initializing multiple services

Promise.allSettled()

┌─────────────────────────────────────────────────────────────────────────┐
│                      Promise.allSettled()                               │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  Promise.allSettled([promise1, promise2, promise3])                     │
│                                                                         │
│  Always resolves with array of outcome objects:                         │
│                                                                         │
│  [                                                                      │
│    { status: 'fulfilled', value: result1 },                             │
│    { status: 'rejected', reason: error },                               │
│    { status: 'fulfilled', value: result3 }                              │
│  ]                                                                      │
│                                                                         │
│  ✅ Never rejects (unless passed non-iterable)                          │
│  ✅ Reports all outcomes, successful or not                             │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Use Cases

• •When you need results from all operations regardless of failures
• •Logging/analytics for multiple operations
• •Graceful handling of partial failures

Promise.race()

┌─────────────────────────────────────────────────────────────────────────┐
│                         Promise.race()                                  │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  Promise.race([promise1, promise2, promise3])                           │
│                                                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐                                  │
│  │  100ms  │  │  50ms   │  │  200ms  │                                  │
│  └────┬────┘  └────┬────┘  └────┬────┘                                  │
│       │            │            │                                       │
│       │            ▼            │                                       │
│       │      🏆 WINNER!         │  ← First to settle                    │
│       │                         │                                       │
│                                                                         │
│  Result: Whatever promise2 resolves/rejects with                        │
│                                                                         │
│  ⚠️  Other promises keep running (just ignored)                         │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Use Cases

• •Implementing timeouts
• •Getting fastest response from multiple sources
• •First-come-first-served patterns

Promise.any()

┌─────────────────────────────────────────────────────────────────────────┐
│                         Promise.any()                                   │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  Promise.any([promise1, promise2, promise3])                            │
│                                                                         │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐                                  │
│  │ REJECT  │  │ FULFILL │  │ REJECT  │                                  │
│  └────┬────┘  └────┬────┘  └────┬────┘                                  │
│       │            │            │                                       │
│       ✗            ▼            ✗                                       │
│                🏆 WINNER!           ← First to FULFILL                  │
│                                                                         │
│  Ignores rejections until one fulfills                                  │
│  If ALL reject → AggregateError with all errors                         │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Use Cases

• •Fallback sources (CDN, backup servers)
• •Any successful result is acceptable
• •Resilient data fetching

Comparison Table

Summary

• •Promise.all() - All must succeed, fail-fast on any error
• •Promise.allSettled() - Get all results, never rejects
• •Promise.race() - First to complete wins
• •Promise.any() - First success wins, ignores failures