手写Promise

    function isPromise(val) { //判断是否是一个promise
        if (val !== null && (typeof val == 'object' || typeof val == 'function')) {
            return typeof val.then === 'function'
        }
    }

    class myPromise {
      #state = 'pending' //初始化状态 pending
      #result = undefined //存放成功或者失败的结果

      #stack = [] //定义一个存放onFulfilled, onRejected的变量
      constructor(executor) {
        //这个玩意对应的就是外面传进来的函数,
        executor(this.resolve.bind(this), this.reject.bind(this))
      }

      resolve(data) { //成功的回调
        if (this.#state !== 'pending') return
        this.#state = 'fulfilled' //改变状态fulfilled
        this.#result = data //赋值成功的结果
        this.#stack.forEach(item => { //状态改变的时候调用

          if (typeof item.onFulfilled == 'function') {
            const data = item.onFulfilled(this.#result)
            try {
              if (isPromise(data)) { //如果是promise 就调用 then 
                data.then(item.resolve, item.reject)
              } else {
                item.resolve(data)
              }
            } catch (err) {
              item.reject(err)
            }
          } else {
            item.resolve(this.#result)
          }
        })
      }

      reject(res) { //失败的回调
        if (this.#state !== 'pending') return
        this.#state = 'rejected' //改变状态rejected
        this.#result = res //赋值失败的结果
        this.#stack.forEach(item => { //状态改变的时候调用
          if (typeof item.onRejected == 'function') {
            const data = item.onRejected(this.#result)
            try {
              if (isPromise(data)) {
                data.then(item.resolve, item.reject) //如果是promise 就调用 then 
              } else {
                item.resolve(data)
              }
            } catch (err) {
              item.reject(err)
            }
          } else {
            item.reject(this.#result)
          }
        })

      }

      then(onFulfilled, onRejected) {
        return new myPromise((resolve, reject) => {
          if (this.#state == 'fulfilled') {
            if (typeof onFulfilled == 'function') {
              const data = onFulfilled(this.#result) //如果状态是成功的，就把结果给then方法的第一个回调
              try {
                if (isPromise(data)) {
                  data.then(resolve, reject) //如果是promise 就调用 then 
                } else {
                  resolve(data)
                }
              } catch (err) {
                reject(err)
              }
            } else {
              resolve(this.#result)
            }
          } else if (this.#state == 'rejected') {

            if (typeof onRejected == 'function') {
              const data = onRejected(this.#result) //如果状态是成功的，就把结果给then方法的第一个回调
              try {
                if (isPromise(data)) {
                  data.then(resolve, reject)//如果是promise 就调用 then 
                } else {
                  resolve(data)
                }

              } catch (err) {
                reject(err)
              }
            } else {
              reject(data)
            }

          } else {
            this.#stack.push({ //如果状态是pending等待的，就把结果先收集好。等状态改变再去调用
              onFulfilled, onRejected, resolve, reject
            })

          }
        })
      }
    }