js实现简易版Promise

const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'

class MyPromise {
  constructor (executor) {
    this.state = PENDING
    this.result = undefined
    this.callbacks = []

    let resolve = value => {
      if (this.state !== PENDING) return
      this.result = value
      this.state = FULFILLED
      setTimeout(() => {
        this.callbacks.forEach(item => item.onFulfilled())
      })
    }

    let reject = reason => {
      if (this.state !== PENDING) return
      this.result = reason
      this.state = REJECTED
      setTimeout(() => {
        this.callbacks.forEach(item => item.onRejected())
      })
    }

    try {
      executor(resolve, reject)
    } catch (err) {
      reject(err)
    }
  }

  then (onFulfilled, onRejected) {
    if (typeof onFulfilled !== 'function') {
      onFulfilled = value => value
    }
    if (typeof onRejected !== 'function') {
      onRejected = reason => {
        throw reason
      }
    }
    return new MyPromise((resolve, reject) => {
      const run = (fun) => {
        let return_v = fun(this.result)
        if (return_v instanceof MyPromise) {
          return_v.then(v => {
            resolve(v)
          }, r => {
            reject(r)
          })
        } else {
          resolve(return_v)
        }
      }
      // 同步成功执行的回调
      if (this.state === FULFILLED) {
        setTimeout(() => {
          run(onFulfilled)
        })
      }
      // 同步执行失败的回调
      if (this.state === REJECTED) {
        setTimeout(() => {
          run(onRejected)
        })
      }
      // 异步执行的回调
      if (this.state === PENDING) {
        this.callbacks.push({
          onFulfilled: () => {
            try {
              run(onFulfilled)
            } catch (err) {
              reject(err)
            }
          },
          onRejected: () => {
            try {
              run(onRejected)
            } catch (err) {
              reject(err)
            }
          }
        })
      }
    })
  }

  catch (onRejected) {
    return this.then(undefined, onRejected)
  }

  static resolve (value) {
    return new MyPromise((resolve, reject) => {
      if (value instanceof MyPromise) {
        value.then(v => {
          resolve(v)
        }, r => {
          reject(r)
        })
      } else {
        resolve(value)
      }
    })
  }

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

  static all (promises) {
    return new MyPromise((resolve, reject) => {
      let count = 0
      let res = []
      for (let i = 0; i < promises.length; i++) {
        promises[i].then(v => {
          count++
          res[i] = v
          if (count === promises.length) {
            resolve(res)
          }
        }, r => {
          reject(r)
        })
      }
    })
  }

  static race (promises) {
    return new MyPromise((resolve, reject) => {
      for (let i = 0; i < promises.length; i++) {
        promises[i].then(v => {
          resolve(v)
        }, r => {
          reject(r)
        })
      }
    })
  }
}