promise一共有pending(进行中)、fulfilled(已成功)、rejected(已失败)三种状态，一旦状态确定就不可更改。初始状态为pending，而且状态变更只有两种：

promise的构造函数，传了一个函数作为参数，这个函数接受promise返回的两个函数：resolve、reject，在构造函数中调用，调用后改变状态。

promise原型上有一个then方法。then方法接受成功回调和失败回调两个参数。then方法内部判断状态， 如果是成功就调用成功回调函数，如果是失败就调用失败回调函数。

构造函数如果调用resolve会传递一个值，作为then方法中成功回调的参数；如果调用reject会传递一个值，作为then方法失败回调的参数。

很明显，我们需要在上述setTimeout内部执行的时候调用resolve，去改变状态。那then方法就会先调用，所以这时候我们应该在then的时候增加一种pending状态判断，这时候要把then传入的函数缓存起来。等到resolve调用的时候再去执行。实现如下：

要实现链式调用，那then调用的时候还是要返回promise对象，因为then方法在promise上， 暂且将返回的promise对象叫做promise2，then方法就叫做then2。

let promise2 = new MyPromise((resolve, reject) => {})

这个返回的promise2调用resolve、reject的时机应该根据then2传入的successCallback、failCallback来决定。

这里要分为成功、失败和异步两种情况

当链式调用没有传递任何参数时，要向下传递值，所以我们在then内部，开始的时候判断， 如果没有成功或者失败回调，要直接返回值、或者失败原因：

/**
 * then不传递参数的时候不参数
 * 逐级传递参数
 ***/ 
 successCallback = successCallback ? successCallback:value => value
 failCallback = failCallback ? failCallback:reason => { throw reason }

具体实现如下：

  // 缓存成功回调函数
  successCallback = []
  // 缓存失败回调函数
  failCallback = []

  resolve = (value) => {
    // 只有PENDING状态能变成FULFILLED状态
    if (this.status !== PENDING) return
    // 状态改变为成功
    this.status = FULFILLED

    this.value = value
    if (this.successCallback.length) this.successCallback.shift()(this.value)
  }
  reject = (reason) => {
    // 只有PENDING状态能变成REJECTED状态
    if (this.status !== PENDING) 
    // 状态变为失败
    this.status = REJECTED

    this.reason = reason

    if (this.failCallback.length) this.failCallback.shift()(this.reason)
  }
  then = (successCallback, failCallback) => {
    /**
     * then不传递参数的时候不参数
     * 逐级传递参数
     * **/ 
    successCallback = successCallback ? successCallback:value => value
    failCallback = failCallback ? failCallback:reason => { throw reason }
    const promise2 = new MyPromise((resolve, reject) => {
      if (this.status === FULFILLED) {
        /**
         * 判断result的值是普通值还是promise对象：
         * 如果是普通值 直接调用resolve
         * 如果是promise对象 查看promise对象返回的结果
         * 再根据promise对象返回的结果 决定调用resolve还是调用reject
         * **/
        let result = successCallback(this.value)
        checkPromise(result, resolve, reject)
      } else if (this.status === REJECTED) {
        let result = failCallback(this.reason)
        checkPromise(result, resolve, reject)
      } else {
        /**
         * pending状态 暂存成功回调和失败回调
         * 异步情况处理
         * **/
        this.successCallback.push(() => {
          /**
           * 判断result的值是普通值还是promise对象：
           * 如果是普通值 直接调用resolve
           * 如果是promise对象 查看promise对象返回的结果
           * 再根据promise对象返回的结果 决定调用resolve还是调用reject
           * **/
          let result = successCallback(this.value)
          checkPromise(result, resolve, reject)
        })
        this.failCallback.push(() => {
          /**
           * 判断result的值是普通值还是promise对象：
           * 如果是普通值 直接调用resolve
           * 如果是promise对象 查看promise对象返回的结果
           * 再根据promise对象返回的结果 决定调用resolve还是调用reject
           * **/
          let result = failCallback(this.value)
          checkPromise(result, resolve, reject)
        })
      }
    })
    return promise2
  }

到这里 我们已经实现了promise的核心方法，下面再来补充promise 的一些调用方法。

catch实现

首先，为了代码的健壮性，我们要try-catch异常捕获。

在构造函数的时候，当捕获到异常要直接调用reject方法。

try {
   executor(this.resolve, this.reject)
} catch (error) {
   this.reject(error)
}

在then方法中， 调用成功或失败回调的时候，如果捕获到异常，就直接走reject方法了。

try {
	let result = successCallback(this.value)
	checkPromise(result, resolve, reject)
} catch(error) {
	reject(error)
}

观察一下：

  pro.then()
     .catch(e => {
         
     })

catch 是promise原型上的，方法接收一个失败回调，实现如下：

 catch = (failCallback) => {
    this.then(null, failCallback)
  }