promise.all()

Hard

Prompt

Implement a function called customPromiseAll that takes an array of promises as input and returns a new promise that resolves with an array of resolved values from the input promises, or rejects with the reason of the first promise that was rejected.

The function should have the following signature:

/**
 * Implement the `customPromiseAll` function
 * @param {Array<Promise>} promises - An array of Promises
 * @returns {Promise<Array>} - A new Promise that resolves with an array of resolved
 *                             values from the input promises, or rejects with the
 *                             reason of the first promise that was rejected.
 */
function customPromiseAll(promises) {
  // Your implementation here
}

The customPromiseAll function should behave similar to the native Promise.all method in JavaScript, but you cannot use Promise.all in your implementation.

Here are some examples to test your solution:

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

customPromiseAll([promise1, promise2, promise3]).then(
  (values) => {
    console.log(values); // Expected output: [3, 42, "foo"]
  }
);

const promise1 = Promise.reject('Error 1');
const promise2 = Promise.resolve(2);
const promise3 = Promise.resolve(3);

customPromiseAll([promise1, promise2, promise3])
  .then((values) => {
    console.log(values); // This line should not be reached
  })
  .catch((error) => {
    console.log(error); // Expected output: "Error 1"
  });

customPromiseAll([]).then((values) => {
  console.log(values); // Expected output: []
});

Your implementation should handle various cases, including an empty input array, a mix of resolved and rejected promises, and promises that resolve with non-Promise values.

Solution

Explanation

• The function takes an array of promises as input.
• It initializes an empty array results to store the resolved values from the input promises.
• It initializes a variable completedPromisesCount to keep track of the number of promises that have been resolved.
• The function creates and returns a new Promise.
• Inside the Promise executor function, it iterates over the input promises array using the forEach method.
• For each promise in the array:
  • It calls Promise.resolve(promise) to ensure that the value is a Promise object, even if it's a non-Promise value like a number or a string.
  • It chains a then handler to the resolved Promise, which:
    • Increments the completedPromisesCount counter.
    • Stores the resolved value in the results array at the corresponding index (results[index] = value).
    • If all promises have been resolved (completedPromisesCount === promises.length), it resolves the outer Promise with the results array.
  • It also chains a catch handler to handle any rejected promises, which rejects the outer Promise with the reason for rejection.
• If the input promises array is empty, the outer Promise is immediately resolved with an empty array.