Promise/A+ 规范

英文：https://promisesaplus.com/
翻译：https://malcolmyu.github.io/2015/06/12/Promises-A-Plus/

参考：

class

class Promise1 {
  constructor(executor) {
    // 初始化state为等待态
    this.state = "pending";
    // 成功的值
    this.value = undefined;
    // 失败的原因
    this.reason = undefined;
    // 成功存放的数组
    this.onResolvedCallbacks = [];
    // 失败存放法数组
    this.onRejectedCallbacks = [];
    let resolve = (value) => {
      // state改变,resolve调用就会失败
      if (this.state === "pending") {
        // resolve调用后，state转化为成功态
        this.state = "fulfilled";
        // 储存成功的值
        this.value = value;
        // 一旦resolve执行，调用成功数组的函数
        this.onResolvedCallbacks.forEach((fn) => fn());
      }
    };
    let reject = (reason) => {
      // state改变,reject调用就会失败
      if (this.state === "pending") {
        // reject调用后，state转化为失败态
        this.state = "rejected";
        // 储存失败的原因
        this.reason = reason;
        // 一旦reject执行，调用失败数组的函数
        this.onRejectedCallbacks.forEach((fn) => fn());
      }
    };
    // 如果executor执行报错，直接执行reject
    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err);
    }
  }
}

then

  then(onFulfilled, onRejected) {
    switch (this.state) {
      case "pending":
        this.onResolvedCallbacks.push(() => {
          onFulfilled(this.value); // onFulfilled传入到成功数组
        });
        this.onRejectedCallbacks.push(() => {
          onRejected(this.reason); // onRejected传入到失败数组
        });
        break;
      case "fulfilled": // 状态为fulfilled，执行onFulfilled，传入成功的值
        onFulfilled(this.value);
        break;
      case "rejected":
        onRejected(this.reason); // 状态为rejected，执行onRejected，传入失败的原因
        break;
    }
  }

支持链式调用

function then(onFulfilled, onReject) {
  return new Promise1((resolve, reject) => {
    // 封装前一个promise成功时执行的函数
    let fulfilled = () => {
      try {
        const result = onFulfilled(this.value); // 承前
        return result instanceof Promise1
          ? result.then(resolve, reject)
          : resolve(result); //启后
      } catch (err) {
        reject(err);
      }
    };
    let rejected = () => {
      try {
        const result = onReject(this.reason);
        return result instanceof Promise1
          ? result.then(resolve, reject)
          : reject(result);
      } catch (err) {
        reject(err);
      }
    };
    switch (this.state) {
      case "pending":
        this.onResolvedCallbacks.push(fulfilled);
        this.onRejectedCallbacks.push(rejected);
        break;
      case "fulfilled":
        fulfilled();
        break;
      case "rejected":
        rejected();
        break;
    }
  });
}

Promise.resolve

Promsie.resolve(value)可以将任何值转成值为 value 状态是 fulfilled 的 Promise，但如果传入的值本身是 Promise 则会原样返回它。

Promise.resolve = function(value) {
    // 如果是 Promsie 或 thenable对象，则直接输出它
   if (value instanceof Promise || ((typeof value === 'object') && 'then' in value)) {
         return value;
   }
    return new Promise(resolve => resolve(value))
}

Promise.reject

Promise.reject = function (reason) {
  return new Promise(function (resolve, reject) {
    reject(reason);
  });
}

Promise.all

function PromiseAll(promises) {
  return new Promise((resolve, reject) => {
    // 参数判断
    if (!Array.isArray(promises)) {
      throw new TypeError("promises must be an array");
    }
    let result = []; // 存放结果
    let count = 0; // 记录有几个resolved
    promises.forEach((promise, index) => {
      promise.then(
        (res) => {
          result[index] = res;
          count++;
          count === promises.length && resolve(result); // 判断是否已经完成
        },
        (err) => {
          reject(err);
        }
      );
    });
  });

Promise.race

PromiseRace = (promises) => {
  return new Promise((resolve, reject) => {
    promises.forEach((p) => {
      // 哪个先改变状态，我们返回的Promise也将会是什么状态
      Promise.resolve(p).then(resolve).catch(reject);
    });
  });
};

Promise.allSettled

function PromiseAllSettled(promises) {
  let arr = [],
    count = 0;
  return new Promise((resolve, reject) => {
    promises.forEach((item, i) => {
      Promise.resolve(item).then(
        (res) => {
          arr[i] = { status: "fulfilled", val: res };
          count += 1;
          if (count === promises.length) resolve(arr);
        },
        (err) => {
          arr[i] = { status: "rejected", val: err };
          count += 1;
          if (count === promises.length) resolve(arr);
        }
      );
    });
  });
}