帮我写一个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()。

Promise.all() 方法接收一个由 Promise 对象组成的数组作为参数，在这个数组中，每个 Promise 都是一段异步代码，每个 Promise 在异步操作完成后会返回一个值，这些值会按照 Promise 在数组中的顺序返回到 Promise.all() 方法的回调函数中。

下面是 Promise.all() 方法的手写代码示例：

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

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

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

使用示例：

let promise1 = Promise.resolve(1);
let promise2 = Promise.resolve(2);
let promise3 = Promise.resolve(3);

promiseAll([promise1, promise2, promise3]).then((results) => {
console.log(results); // [1, 2, 3]
}).catch((error) => {
console.error(error);
});

手写一个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);
});

希望这对你有帮助！