Question 19

Question

Can you explain the difference between Promise.all(), Promise.allSettled(), Promise.race(), and Promise.any().

Answer

Each of the methods Promise.all(), Promise.allSettled(), Promise.race(), and Promise.any() provides a unique way to manage the resolution or rejection of multiple promises, catering to different use cases. Let's examine their distinct behaviors:

1. Promise.all()

Promise.all() accepts an iterable of promises as input and returns a new promise that resolves when all the input promises resolve successfully. If any of the input promises rejects, the returned promise also rejects with the reason from the first rejected promise. Essentially, Promise.all() acts as a collective success checkpoint for multiple asynchronous operations.

const promise1 = Promise.resolve(1);
const promise2 = new Promise((resolve, reject) => { 
  setTimeout(() => resolve('Resolved'), 1000); 
});
const promise3 = Promise.reject('Rejected');

Promise.all([promise1, promise2, promise3])
  .then((values) => {
    console.log("All promises resolved:", values); // This block will not execute
  })
  .catch((error) => {
    console.error("At least one promise rejected:", error); // Outputs: At least one promise rejected: Rejected
  });

2. Promise.allSettled()

Promise.allSettled() behaves similarly to Promise.all(), but it returns an array of settled promises, regardless of whether they resolved or rejected. Each element in the returned array represents the state and result (if any) of the corresponding input promise. This method is useful when you need information about the status of all promises, even if some failed.

Promise.allSettled([promise1, promise2, promise3])
  .then((results) => {
    console.log("All promises settled:", results); 
  });

3. Promise.race()

Promise.race() accepts an iterable of promises and returns a new promise that resolves or rejects as soon as one of the input promises does so. It prioritizes speed, resolving or rejecting based on the fastest outcome among the given promises. This method is useful when you need to handle the first completed promise without waiting for others.

const fastPromise = Promise.resolve('Fast');
const slowPromise = new Promise((resolve) => setTimeout(resolve, 1000, 'Slow'));

Promise.race([fastPromise, slowPromise])
  .then((result) => {
    console.log("First promise resolved:", result); // Outputs: First promise resolved: Fast
  });

4. Promise.any()

Promise.any() accepts an iterable of promises and returns a new promise that resolves with the value of the first promise to resolve in the input iterable. If all input promises reject, Promise.any() rejects with an AggregateError containing information about all rejected promises. This method is useful when you need to wait for at least one promise to succeed, regardless of how many others might fail.

const successfulPromise = Promise.resolve('Success');
const failingPromises = [
  new Promise((_, reject) => reject('Rejected 1')),
  new Promise((_, reject) => reject('Rejected 2'))
];

Promise.any([successfulPromise, ...failingPromises])
  .then((result) => {
    console.log("First resolved promise:", result); // Outputs: First resolved promise: Success
  })
  .catch((error) => {
    console.error("All promises rejected:", error); 
  });