Polyfills of Promise.all()

Function of Promise.all()

Input : It takes array of Promise (not necessary)
Output: It return Promise which contain array of result of all success promise.
Note: If any promise fails, it reject immediately.

code for the Promise.myAll()

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

let results = [];
let completedPromises = 0;

promises.forEach(function (promise, index) {
  // Use Promise.resolve to handle non-promise values
  Promise.resolve(promise)
    .then(function (value) {
      results[index] = value;
      completedPromises += 1;

      // If all promises are resolved
      if (completedPromises === promises.length) {
        resolve(results);
      }
    })
    .catch(function (error) {
      reject(error); // Reject if any promise fails
    });
});

// Handle case with empty array of promises
if (promises.length === 0) {
  resolve([]);
}

});
};
`

1. If all promise resolved successfully

. All promises resolve, and their results are stored in the results array.
. When the number of resolved promises equals the length of the input array, the outer promise resolves with the results array.

2. Why to use Promise.resolve()

. It is not neccessay that in array of promises all value must be a promise, it can by any value - number, string, or any synchronus function.

1. If the passed value is already a promise - It will return the same promise, ensuring that no extra wrapping or changing occur.

2. If the passed value is not a promise - It will wrap the value in resolved promise, allowing to treat it like a promise and handle it with .then()

3. Why Promise.resolve(), why not Promise.reject()

so that it resolve with value, if we use reject it will caught in catch block with value considered as error.

4. What happend if any Promise fails?

1. This trigger the reject() call of the outer promie causing the Promise.myAll() to reject immediately.
2. foreach loop will continue, as it synchronus program
3. rest of promise will resolve and its valued added to result but as completedPromise!=promises.length it not resolve, and if still try it will be ignored because Promise.myAll() is not in pending state now.

If you still have any questions, feel free to ask in the comments!