帮我写一个promise.all

好的，以下是一个简单的 Promise.all 实现：

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

    for (let i = 0; i < promises.length; i++) {
      promises[i]
        .then((result) => {
          results[i] = result;
          count++;

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

这个实现接收一个 Promise 数组作为参数，返回一个新的 Promise。在所有输入的 Promise 都解决后，返回的 Promise 才会被解决。返回的 Promise 会解决为一个结果数组，其顺序与传入 Promise 数组的顺序相同。如果输入 Promise 数组中的任何一个 Promise 被拒绝，返回的 Promise 将被拒绝，原因是第一个被拒绝的 Promise 的拒绝原因。

相关问题

帮我手写一个promise.all

好的，这里是一个简单的手写 Promise.all 的实现：

function promiseAll(promises) {
  return new Promise(function(resolve, reject) {
    if (!Array.isArray(promises)) {
      return reject(new TypeError('arguments must be an array'));
    }

    var resolvedCount = 0;
    var promisesCount = promises.length;
    var results = [];

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

        if (resolvedCount === promisesCount) {
          return resolve(results);
        }
      }).catch(function(error) {
        return reject(error);
      });
    });
  });
}

这个函数接收一个 Promise 数组，返回一个新的 Promise，当所有的 Promise 都完成时，返回一个结果数组，数组中的元素顺序与传入的 Promise 数组中的顺序一致。如果数组中的任意一个 Promise 被拒绝（rejected），则返回的 Promise 也会被拒绝，并且返回的错误是被拒绝的 Promise 的错误。

手写一个promise.all

可以使用以下代码手写一个 `Promise.all` 函数：

function PromiseAll(promises) {
  return new Promise((resolve, reject) => {
    if (!Array.isArray(promises)) {
      return reject(new TypeError('Promise.all requires an array'));
    }

    const results = [];
    let remaining = promises.length;

    function resolver(index) {
      return value => {
        resolveAll(index, value);
      };
    }

    function rejecter(reason) {
      reject(reason);
    }

    function resolveAll(index, value) {
      results[index] = value;
      if (--remaining === 0) {
        resolve(results);
      }
    }

    for (let i = 0; i < promises.length; i++) {
      Promise.resolve(promises[i]).then(resolver(i), rejecter);
    }
  });
}

该函数接受一个包含多个 Promise 实例的数组，并返回一个新的 Promise 实例。如果传入的不是一个数组，则返回一个 reject 状态的 Promise 实例，并将一个 TypeError 作为原因。

如果传入的数组中的所有 Promise 都是 fulfilled 状态，则返回的 Promise 实例也是 fulfilled 状态，并将所有 Promise 的返回值作为一个数组传递给它的回调函数。如果传入的数组中至少有一个 Promise 是 rejected 状态，则返回的 Promise 实例也是 rejected 状态，并将第一个被 reject 的 Promise 的原因作为参数传递给它的回调函数。

你可以像使用标准的 `Promise.all` 函数一样使用这个函数。例如：

PromiseAll([promise1, promise2, promise3]).then(values => {
  console.log(values); // [value1, value2, value3]
}).catch(reason => {
  console.error(reason);
});

希望这对你有帮助！