function MyPromise(fn) {
  this.resData // 最终resolve时的value 或者 最终reject时的reason
  this.onFulfilledList = [] // 当resolve之后，执行的内部回调队列
  this.onRejectedList = [] // 当reject之后，执行的内部回调队列
  this.status = 'pending' // 内部的状态，只能是pending、fulfilled、rejected中的一种，且只能由pending变化为其他两种，且一旦状态改变过，就无法再进行改变

  // 第三步：执行resolve
  // 注：极少数情况，resolve在then之前调用，相当于Promise对象状态已经确定后再去执行then注册的回调
  const resolve = data => {
    // 只有在pending状态下才会继续，保证resolve状态不会被改变
    if (this.status != 'pending') return
    // 同步代码，立即修改状态为fulfilled，赋值resData，执行回调
    this.status = 'fulfilled'
    this.resData = data
    // 若执行此回调时，onFulfilledList为空，则相当于无事发生
    if (this.onFulfilledList.length > 0) {
      for (let fn of this.onFulfilledList) {
        fn(data)
      }
    }
  }

  // 第三步：执行reject
  // 注：极少数情况，reject在then之前调用，相当于Promise对象状态已经确定后再去执行then注册的回调
  const reject = reason => {
    // 只有在pending状态下才会继续，保证reject状态不会被改变
    if (this.status != 'pending') return
    // 同步代码，立即修改状态为rejected，赋值resData，执行回调
    this.status = 'rejected'
    this.resData = reason
    // 若执行此回调时，onRejectedList为空，则相当于无事发生
    if (this.onRejectedList.length > 0) {
      for (let fn of this.onRejectedList) {
        fn(reason)
      }
    }
  }

  // 第一步执行fn，这里给使用者提供一个权力：何时来resolve或reject
  try { // try catch 是为了捕获错误
    fn(resolve, reject)
  } catch (reason) {
    reject(reason) // 若捕获到错误，则直接reject
  }

}

// 第二步：调用then来注册回调，以备原来的Promise对象的状态发生改变时，执行相应的回调方法
// 注：这是最核心的部分
MyPromise.prototype.then = function (onfulfilled, onrejected) {
  const self = this
  // onfulfilled 和 onrejected 分别对应 fulfilled 和 rejected 两种状态的回调方法
  // 参数若不存在，则给予默认值，此默认值用于实现Promise的穿透效果
  if (typeof onfulfilled !== 'function') onfulfilled = value => value
  if (typeof onrejected !== 'function') onrejected = reason => { throw reason }

  // 若注册回调时，原来的Promise对象处于pending状态
  // 我们把原来的Promise对象称为oldP
  // 注：这是最复杂的部分
  if (this.status == 'pending') {
    // 则return一个新的Promise对象，我们称它为newP
    return new MyPromise((resolve, reject) => {
      // newP最终会resolve还是reject，取决于then注册的回调执行后的结果

      // 此时创建一个回调函数，主要目标是：当oldP完成resolve的时候，执行此回调，并且根据执行结果改变newP的状态
      let newOnFulfilled = function (data) {
        let res
        try { // try catch 是为了捕获错误
          // 此处执行的then注册的回调
          res = onfulfilled(data)
        } catch (e) {
          reject(e) // 若捕获到错误，则直接reject
          return
        }
        // 若回调执行的结果为Promise类型，我们称它为3P
        if (res instanceof MyPromise) {
          // 则3P的状态将决定newP的状态，此处实现了Promise之间的串行等待
          // 3P达到fulfilled状态的时候，会调用newP的resolve
          // 3P达到rejected状态的时候，会调用newP的reject
          res.then(resolve, reject)
        } else {
          // 若回调执行结果不为Promise类型，则以此值作为value，令newP达到resolve
          resolve(res)
        }
      }
      // 将此回调函数放入外层Promise的onFulfilledList
      self.onFulfilledList.push(newOnFulfilled)

      // 大体与上面部分相同
      let newOnRejected = function (data) {
        let res
        try {
          res = onrejected(data)
        } catch (e) {
          reject(e)
          return
        }

        if (res instanceof MyPromise) {
          res.then(resolve, reject)
        } else {
          // 注意此处仍然是newP达到resolve，因为oldP达到reject并不影响新的Promise的状态，只有then注册的回调的结果，才可以影响
          resolve(res)
        }
      }

      // 将此回调函数放入外层Promise的onRejectedList
      self.onRejectedList.push(newOnRejected)
    })


    // 若注册回调时，Promise对象处于fulfilled状态
  } else if (this.status == 'fulfilled') {
    // 直接执行回调方法即可
    let res = onfulfilled(this.resData)
    // 若回调方法的结果为Promise对象，则直接return，即为执行then之后得到的新的Promise对象
    // or
    // 若回调方法的结果不为Promise对象，则作为新的Promise对象的value，且默认新的Promise对象状态为fulfilled
    return MyPromise.resolve(res)

    // 若注册回调时，Promise对象处于rejected状态，大体与上面部分相同
  } else if (this.status == 'rejected') {
    // 直接执行回调方法即可
    let res = onrejected(this.resData)
    // 若回调方法的结果为Promise对象，则直接return，即为执行then之后得到的新的Promise对象
    // or
    // 若回调方法的结果不为Promise对象，则作为新的Promise对象的value，且新的Promise对象状态仍然为fulfilled
    return MyPromise.resolve(res)
  }
}

// catch只是一个语法糖，完全可以用then替代
MyPromise.prototype.catch = function (onrejected) {
  return this.then(null, onrejected)
}

// 相当于Promise.resolve方法，生成一个状态为fulfilled的Promise对象
MyPromise.resolve = function (data) {
  if (data instanceof MyPromise) {
    return data
  } else {
    return new MyPromise(resolve => {
      resolve(data)
    })
  }
}

// 相当于Promise.reject方法，生成一个状态为rejected的Promise对象
MyPromise.reject = function (data) {
  return new MyPromise((undefined, reject) => {
    reject(data)
  })
}