Promise 的实现

class Pro {
  callbacks = [];
  state = "pending";
  value = null;
  constructor(fn) {
    // 初始化，把resolve作为参数传入，等待调用
    fn(this.resolve.bind(this));
  }
  // callback为回调，先注册，也就是放入callbacks数组中
  then(callback) {
    if (this.state === "pending") {
      this.callbacks.push(callback);
    } else {
      // 由于state不是pending, 遵循promise状态只能改一次的要求，我们直接操作回调传入参数执行
      callback(this.value);
    }
    return this;
  }
  // resolve也就是fn的第一次参数，循环执行所有callback
  resolve(value) {
    this.state = "fulfilled";
    // setTimeout使内部变成异步，在同步执行完最后执行这里，处理fn是同步的情况下then中的回调函数已经注册，然后在这里去执行，不会出现callbacks是空数组的情况
    setTimeout(() => {
      this.value = value;
      this.callbacks.forEach((callback) => callback(value));
    });
  }
}

new Pro((resolve) => {
  setTimeout(() => {
    console.log(0);
    resolve("resolve");
  }, 2000);
})
  .then((tip) => {
    console.log(1);
    console.log(tip);
  })
  .then((tip) => {
    console.log(2);
    console.log(tip);
  });

Promise.prototype.all = function (promises) {
  let results = [];
  let promiseCount = 0;
  let promisesLength = promises.length;
  return new Promise(function (resolve, reject) {
    for (let item of promises) {
      // 执行每个item
      Promise.resolve(item).then(
        function (res) {
          promiseCount++;
          // 按照顺序插入结果
          results[i] = res;
          // 如果全部执行成功，返回成功
          if (promiseCount === promisesLength) {
            return resolve(results);
          }
        },
        function (err) {
          return reject(err);
        }
      );
    }
  });
};

Promise.prototype.race = function (promises) {
  return new Promise((resolve, reject) => {
    for (let item of promises) {
      Promise.resolve(item)
        .then((res) => {
          return resolve(res);
        })
        .catch((err) => {
          return reject(err);
        });
    }
  });
};