15. Promise Combinators: all, allSettled, race, any & Concurrency Control • JavaScript & Advanced ES6+ (0-to-Hero Big Tech Standard) • Rishabh Ki Kaksha

Jab tujhe ek sath **multiple API requests ya async tasks** chalane hon, toh JavaScript 4 powerful weapons deta hai jinhe **Promise Combinators** kehte hain:

1. **`Promise.all()`** -> *"Sabke sab pass hone chahiye, ek bhi fail toh sab fail (Fail-Fast)"*
2. **`Promise.allSettled()`** -> *"Sabka report card chahiye, chahe koi pass ho ya fail"*
3. **`Promise.race()`** -> *"Jo sabse pehle finish line cross kare (chahe pass ya fail)"*
4. **`Promise.any()`** -> *"Pehla successful winner chahiye, sab fail hone par hi error"*

---

### 2. The 4 Combinators Master Comparison Matrix

| Combinator | Kab Resolve Hota Hai? | Kab Reject Hota Hai? | Output Format |
| :--- | :--- | :--- | :--- |
| **`Promise.all`** | Jab **Saare Promises** resolve ho jayein | Jaise hi **Ek Bhi** reject ho (Fail-Fast) | `[res1, res2, res3]` (Array of values) |
| **`Promise.allSettled`** | Jab **Saare Promises** settle (complete) ho jayein | **Kabhi Reject Nahi Hota** | `[{status:'fulfilled', value:...}, {status:'rejected', reason:...}]` |
| **`Promise.race`** | Jo sabse **Pehla** settle ho (agar pehla resolve hua toh) | Agar sabse **Pehla** reject ho jaye | Single First Value / Error |
| **`Promise.any`** | Jo sabse **Pehla Success** ho | Jab **Saare ke Saare** reject ho jayein (`AggregateError`) | Single First Success Value |

---

### 3. Code Examples & Real-World Use Cases

#### A) `Promise.all()` - Dashboard Data Loading
```javascript
const p1 = fetchUserProfile();
const p2 = fetchUserNotifications();
const p3 = fetchUserPreferences();

// Teeno parallel chalenge (Agar API 1 sec leti hai toh total time sirf 1 sec lagega, 3 sec nahi!)
Promise.all([p1, p2, p3])
    .then(([profile, notifications, preferences]) => {
        renderDashboard(profile, notifications, preferences);
    })
    .catch(err => {
        console.error("Dashboard failed to load:", err);
    });
```

#### B) `Promise.race()` - API Request Timeout Controller
```javascript
function fetchWithTimeout(url, timeoutMs = 5000) {
    const apiCall = fetch(url);
    const timeout = new Promise((_, reject) => 
        setTimeout(() => reject(new Error("Request Timed Out!")), timeoutMs)
    );
    return Promise.race([apiCall, timeout]);
}
```

---

### 4. Big Tech Polyfill: `Promise.all` From Scratch

```javascript
Promise.myAll = function(promises) {
    return new Promise((resolve, reject) => {
        if (!Array.isArray(promises)) {
            return reject(new TypeError("Argument must be an array"));
        }

const results = [];
        let completedCount = 0;
        const total = promises.length;

if (total === 0) return resolve(results);

promises.forEach((promise, index) => {
            // Promise.resolve wrap karta hai non-promise values ko bhi handle karne ke liye
            Promise.resolve(promise)
                .then(value => {
                    results[index] = value; // Preserve original input order!
                    completedCount++;
                    if (completedCount === total) {
                        resolve(results);
                    }
                })
                .catch(error => {
                    reject(error); // Immediate fail-fast
                });
        });
    });
};
```

---

### 5. Advanced: Concurrent Request Throttling (Concurrency Limiter)

Agar tujhe 1,000 files download karni hain, toh 1,000 requests ek sath fire karoge toh server crash ho jayega (Socket exhaustion).  
Hume **Batching / Concurrency Pool** (e.g. at most 3 requests in parallel) implement karna padta hai:

```javascript
async function asyncPool(poolLimit, items, asyncFn) {
    const results = [];
    const executing = [];

for (const item of items) {
        const p = Promise.resolve().then(() => asyncFn(item));
        results.push(p);

if (poolLimit <= items.length) {
            const e = p.then(() => executing.splice(executing.indexOf(e), 1));
            executing.push(e);
            if (executing.length >= poolLimit) {
                await Promise.race(executing); // Wait for fastest slot to open!
            }
        }
    }
    return Promise.all(results);
}
```

---

### 6. Interview Ke 3 Sawal Is Topic Se

1. **`Promise.all` me results ka order kya hota hai?** -> Hamesha input array ke order me hi array return hota hai, chahe API 2 pehle resolve ho jaye aur API 1 baad me.
2. **`Promise.any()` jab fail hota hai toh kya error throw karta hai?** -> `AggregateError` jisme `errors` property ke andar saari rejections ka array hota hai.
3. **`Promise.all` vs `Promise.allSettled` kab use karein?** -> Agar critical interdependent data hai (ek fail toh baki bekar), use `all`. Agar independent batch processing hai (jaise 10 emails bhejna, 2 fail ho jayein toh bhi 8 send hone chahiye), use `allSettled`.

---
**Next Topic:** 16. async/await Internals, Generators (function*) & Coroutine Emulation

Loading lesson content...

🎯 Big Tech Coding & Interview Challenges

Practice these curated problems. Click "Load in Sandbox" to solve live in the Code Studio!

1 Questions

Medium

1. Promise.all Polyfill Implementation

Implement `Promise.myAll(promises)` from scratch that fulfills with an array of values in matching input order, or rejects immediately on the first error.

💡 View Pro Interview Hint

• Track completed counter and assign results by index.

JavaScript

Full IDE

Live Execution Terminal

Click "Execute Live" to run code.
                

🎯 Big Tech Coding & Interview Challenges

1. Promise.all Polyfill Implementation

Lesson Mastery AI Quiz

AI Doubt Solver

CERTIFICATE OF COMPLETION

Rishabh Gehlot

PHP 8+ & Laravel 11 Master Track