手写一个promise.all代码

当然，下面是一个手写的`promise.all`的简单实现代码：

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

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

          if (completedPromises === promises.length) {
            resolve(results);
          }
        })
        .catch(reject);
    }
  });
}

这个`customPromiseAll`函数接受一个包含多个promise的数组作为参数，并返回一个新的promise。它会等待所有的promise都完成后，将结果以数组的形式传递给`resolve`函数。

注意：这只是一个简单的示例，实际上`promise.all`还需要处理一些边界情况，比如传入空数组、非promise对象等。在实际开发中，建议使用原生的`Promise.all`方法。

相关问题

手写一个Promise.all

好的，下面是手动实现的 `Promise.all` 的代码：

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

    function checkCompletion() {
      counter++;
      if (counter === promises.length) {
        resolve(results);
      }
    }

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

    if (promises.length === 0) {
      resolve(results);
    }
  });
}

该函数接受一个 Promise 数组作为参数，并返回一个新的 Promise。它会等待所有的 Promise 完成，并将其结果以数组的形式传递给新的 Promise。

使用示例：

const promise1 = Promise.resolve(1);
const promise2 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 2);
});
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 200, 3);
});

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

希望这个手写的 `Promise.all` 对你有所帮助！如果还有其他问题，请随时提问。

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

希望这对你有帮助！