手写Promise

//js
    const PENDING = 'pending';
    const RESOLVED = 'resolved';
    const REJECTED = 'rejected';

    function MyPromise(fn) {

      // 保存初始化状态
      var self = this;

      // 初始化状态
      this.state = PENDING;

      // 用于保存 resolve 或者 rejected 传入的值
      this.value = null;

      // 用于保存 resolve 的回调函数
      this.resolvedCallbacks = [];

      // 用于保存 reject 的回调函数
      this.rejectedCallbacks = [];

      // 状态转变为 resolved 方法
      function resolve(value) {

        // 判断传入元素是否为 Promise 值，如果是，则状态改变必须等待前一个状态改变后再进行改变
        if (value instanceof MyPromise) {
          return value.then(resolve, reject)
        }

        // 保证代码的执行顺序为本轮事件循环的末尾
        setTimeout(() => {
          // 只有状态为 pending 时才能转变，
          if (self.state === PENDING) {

            // 修改状态
            self.state = RESOLVED;

            // 设置传入的值
            self.value = value;

            // 执行回调函数
            self.resolvedCallbacks.forEach(callback => {
              callback(value)
            });
          }
        }, 0);

      }


      // 状态转变为 rejected 方法
      function reject(value) {

        // 保证代码的执行顺序为本轮事件循环的末尾
        setTimeout(() => {
          // 只有状态为 pending 时才能转变
          if (self.state === PENDING) {

            // 修改状态
            self.state = REJECTED;

            // 设置传入的值
            self.value = value;

            // 执行回调函数
            self.rejectedCallbacks.forEach(callback => {
              callback(value)
            });
          }
        }, 0);

      }

      // 将两个方法传入函数执行
      try {
        fn(resolve, reject)
      } catch (e) {

        // 遇到错误时，捕获错误，执行 reject 函数
        reject(e)
      }
    }


    MyPromise.prototype.then = function (onResolved, onRejected) {

      // 首先判断两个参数是否为函数类型，因为这两个参数是可选参数
      onResolved = typeof onResolved === "function" ? onResolved : function (value) {
        return value;
      };

      onRejected = typeof onRejected === "function" ? onRejected : function (error) {
        throw error;
      };


      // 如果是等待状态，则将函数加入对应列表中
      if (this.state === PENDING) {
        this.resolvedCallbacks.push(onResolved);
        this.rejectedCallbacks.push(onRejected);
      }

      // 如果状态已经凝固，则直接执行对应状态的函数

      if (this.state === RESOLVED) {
        onResolved(this.value);
      }

      if (this.state === REJECTED) {
        onRejected(this.value);
      }

    }