JS手写——手写Promise中的then、all、race等方法

class Promise_ {
  static PENDING = 'pengind'; static FULFILLED = 'fulfilled'; static REJECTED = 'rejected'
  constructor(executor) {
    this.status = Promise_.PENDING
    this.reason = null
    this.result = null
    this.resolveCallback = []
    this.rejectCallback = []
    try {
      executor(this.resvole.bind(this), this.reject.bind(this))
    } catch {
      this.reject(error)
    }
  }
  resolve(result) {
    setTimeout(() => {
      if (this.status == Promise_.PENDING) {
        this.status = Promise_.FULFILLED
        this.result = result
        this.resolveCallback.forEach((callback) => {
          callback(result)
        })
      }
    })

  }
  reject(reason) {
    setTimeout(() => {
      if (this.status == Promise_.PENDING) {
        this.status = Promise_.REJECTED
        this.reason = reason
        this.resolveCallback.forEach((callback) => {
          callback(reason)
        })
      }
    })

  }

  then(onResolved, onRejected) {
    return new Promise_((resolve, reject) => {
      onResolved = typeof onRejected == 'function' ? onResolved : () => { }
      onRejected = typeof onRejected == 'function' ? onResolved : () => { }


      if (this.status == Promise_.PENDING) {
        this.resolveCallback.push(onResolved)
        this.rejectCallback.push(onRejected)
      }
      if (this.status == Promise_.FULFILLED) {
        setTimeout(() => {
          onResolved(this.result)
        })
      }
      if (this.status == Promise_.REJECTED) {
        setTimeout(() => {
          onRejected(this.result)
        })
      }
    })
  }

  static resolve = function (value) {
    return new Promise((resolve, reject) => {
      if (value instanceof Promise) {
        value.then(resolve, reject)
      } else {
        resolve(value)
      }
    })
  }

  static reject = function (reason) {
    return new Promise((resolve, reject) => {
      reject(reason)
    })
  }

  static all(promises) {
    promises = promises.map((p) => {
      if (p instanceof Promise_) {
        return p
      } else {
        return Promise_.resolve(p)
      }
    })

    const arr = new Array(promises.length)
    let resolvedCount = 0
    return new Promise((resolve, reject) => {
      promises.forEach((p, index) => {
        p.then(
          result => {
            resolvedCount++
            arr[index] = result
            if (resolvedCount == promises.length) {
              resolve(arr)
            }
          },
          reason => {
            reject(reason)
          }
        )
      })
    })

  }

  static race(promises) {
    return new Promise((resolve, reject) => {
      promises.forEach((promise) => {
        promise.then(result => resolve(result), result => reject(result))
      })
    })
  }
}