手写promise.all

下面是一个简单的手写 Promise.all 实现：

function promiseAll(promises) {
  return new Promise((resolve, reject) => {
    let results = [];
    let count = 0;

    promises.forEach((promise, index) => {
      Promise.resolve(promise).then((result) => {
        results[index] = result;
        count++;

        if (count === promises.length) {
          resolve(results);
        }
      }).catch((error) => {
        reject(error);
      });
    });
  });
}

这个实现创建了一个新的 Promise，通过遍历 promises 数组，将每个 promise 转为一个 resolved 状态的 promise，并在每个 resolved promise 返回结果时保存结果到 results 数组中。当所有的 promise 都返回结果时，将 results 数组作为 Promise.all 的返回值 resolve。如果其中一个 promise 出现错误，则直接 reject。

相关问题

手写Promise.all

Promise.all() 方法接收一个 Promise 对象的数组作为参数，返回一个新的 Promise 对象。当数组中所有的 Promise 对象都成功时，新 Promise 对象才会成功；只要任何一个 Promise 对象失败，新 Promise 对象就会失败。

以下是一个手写的 Promise.all() 方法的实现：

function promiseAll(promises) {
  return new Promise((resolve, reject) => {
    let results = new Array(promises.length);
    let resolvedCount = 0;

    promises.forEach((promise, index) => {
      promise.then(result => {
        results[index] = result;
        resolvedCount++;

        if (resolvedCount === promises.length) {
          resolve(results);
        }
      }).catch(error => {
        reject(error);
      });
    });
  });
}

这个实现中，我们首先创建了一个新的 Promise 对象，并在该 Promise 对象中使用一个数组来存储每个 Promise 对象的结果。我们还定义了一个计数器 resolvedCount，用于跟踪已经解决的 Promise 对象的数量。

然后，我们使用 forEach() 方法遍历传递给 promiseAll() 方法的 Promise 对象数组，并为每个 Promise 对象设置一个 then() 方法来处理成功的情况。在每个成功的 then() 回调函数中，我们将该 Promise 对象的结果存储在结果数组中，并将 resolvedCount 计数器增加 1。如果 resolvedCount 的值等于 Promise 对象的数组的长度，则意味着所有 Promise 对象都已成功解决，我们就可以使用 resolve() 方法来解决新的 Promise 对象，并传递结果数组作为参数。

如果任何一个 Promise 对象失败，则我们使用 catch() 方法处理错误情况，并使用 reject() 方法拒绝新的 Promise 对象。

手写promise.all方法

要手写实现 `Promise.all` 方法，可以按照以下步骤进行操作：

1. 创建一个新的 Promise 对象，并返回它。
2. 在内部创建一个数组 `results`，用于存储每个传入的 Promise 对象的结果。
3. 使用 `Array.from` 方法将传入的参数（可以是数组或类数组对象）转换为一个真正的数组。
4. 遍历数组中的每个 Promise 对象，使用 `Promise.resolve` 方法将其转换为一个 Promise 对象。
5. 对于每个 Promise 对象，使用 `.then` 方法来处理其结果。
- 如果 Promise 对象 resolved，将结果存储到 `results` 数组中。
- 如果 Promise 对象 rejected，直接将整个 `Promise.all` 的 Promise 对象 rejected，并传递该错误给它。
6. 在所有 Promise 对象都处理完毕后，如果没有任何错误，则将 `results` 数组作为参数解析传递给 `Promise.all` 的 Promise 对象，并使其 resolved。

以下是一个示例代码，展示了如何手写实现 `Promise.all` 方法：

function myPromiseAll(promises) {
  return new Promise((resolve, reject) => {
    const results = [];
    const promisesCount = promises.length;
    let resolvedCount = 0;

    if (promisesCount === 0) {
      resolve(results);
      return;
    }

    function handleResolve(index, value) {
      results[index] = value;
      resolvedCount++;

      if (resolvedCount === promisesCount) {
        resolve(results);
      }
    }

    function handleReject(error) {
      reject(error);
    }

    for (let i = 0; i < promisesCount; i++) {
      Promise.resolve(promises[i])
        .then((value) => handleResolve(i, value))
        .catch(handleReject);
    }
  });
}

// 示例 Promise 对象
const promise1 = Promise.resolve(1);
const promise2 = Promise.resolve(2);
const promise3 = new Promise((resolve) => setTimeout(resolve, 1000, 3));

// 使用自定义的 Promise.all 方法
myPromiseAll([promise1, promise2, promise3])
  .then((results) => {
    console.log(results); // 输出: [1, 2, 3]
  })
  .catch((error) => {
    console.log(error);
  });

通过以上代码，你可以手动实现 JavaScript 中的 `Promise.all` 方法。请注意，这只是一个简单的示例，并没有处理所有可能的情况，如传入的参数不是一个数组等。在实际使用中，建议使用 JavaScript 原生的 `Promise.all` 方法来处理多个 Promise 对象的并行操作。