一、promise A+规范

1.存在三种状态 pending, fulflled, rejected

pending

在resolve或reject之前，都处于这种状态

fulflled

最终状态，不可变
promise中reslove后的结果
返回会有一个value值
pending -> resolve(value) -> fulfilled

rejected

最终状态，不可变
promise中reject后的结果
返回会有一个reason值
pending -> reject(reason) -> rejected

2.存在then的链式调用

then接收两个回调，一个是成功回调，一个是失败回调；
当Promise状态为fulfilled执行成功回调，为rejected执行失败回调；
如resolve或reject在定时器里，则定时器结束后再执行then；
then支持链式调用，下一次then执行受上一次then返回值的影响；

二、手写实现简易promise a+规范

实现步骤分析：

实现reject和resolve功能

返回值都存在promiseStatus、promiseResult
所有状态初始的时候都是pending
绑定resolve和reject函数的this，以便于不会随着调用环境的改变而改变

注意：promise当中可能会执行throw,此时相当于执行了reject

实现then

then接收两个参数，成功回调+失败回调
then定时器的异步执行（定时器中包含resolve或reject，则then在它执行完成之后才会执行）
可以实现链式调用+顺序执行

then接收两个回调函数参数，resolve时执行成功回调，反之，执行失败回调

正常情况下，存在定时器时的调用方式如下：

重要知识点： then的两个回调函数，onFulfilled 和 onRejected 应该是微任务

事件循环机制中：执行宏任务时，若遇见微任务，会暂时抽离出来放在微任务栈中，等到（这里有一个类似于异步的处理）该轮宏任务执行完成后，微任务栈中的任务会遵循先进后出的规律，依次进入消息队列(先进先出)当中，等待执行。

实现思想：所以，我们无法保证then在1秒后执行，但是可以保证then中的回调在1秒后执行（将回调暂存起来，等到reject或者resolve执行后再去调用）

initValue中添加：

resolve和reject中添加：

then中添加：

then中链式调用的实现

下一次then接收上一次then返回结果:

规律：

then方法本身会返回一个新的Promise对象；
如果返回值是promise对象，返回值为成功，新promise就是成功；
如果返回值是promise对象，返回值为失败，新promise就是失败；
如果返回值非promise对象，新promise对象就是成功，值为此返回值；

返回值：非promise

返回值：promise

链式调用手写代码实现：

思想：要想让then之后还能then,则直接将then执行完成之后，返回一个新的promise对象就可以了

整个promise a+规范代码实现的完整版本：

完整代码：

class MyPromise {
    // 构造方法
    constructor(executor) {

        // 初始化值
        this.initValue()
        // 初始化this指向
        this.initBind()
      	try {
            // 执行传进来的函数
            executor(this.resolve, this.reject)
        } catch (e) {
            // 捕捉到错误直接执行reject
            this.reject(e)
        }
    }

    initBind() {
        // 初始化this
        this.resolve = this.resolve.bind(this)
        this.reject = this.reject.bind(this)
    }

    initValue() {
        // 初始化值
        this.PromiseResult = null // 终值
        this.PromiseState = 'pending' // 状态
      	this.onFulfilledCallbacks = [] // 保存成功回调
        this.onRejectedCallbacks = [] // 保存失败回调
    }

    resolve(value) {
        // state是不可变的
      	if (this.PromiseState !== 'pending') return
        // 如果执行resolve，状态变为fulfilled
        this.PromiseState = 'fulfilled'
        // 终值为传进来的值
        this.PromiseResult = value
      	// 执行保存的成功回调
      	while (this.onFulfilledCallbacks.length) {
            this.onFulfilledCallbacks.shift()(this.PromiseResult)
        }
    }

    reject(reason) {
        // state是不可变的
        if (this.PromiseState !== 'pending') return
        // 如果执行reject，状态变为rejected
        this.PromiseState = 'rejected'
        // 终值为传进来的reason
        this.PromiseResult = reason
        // 执行保存的失败回调
	      while (this.onRejectedCallbacks.length) {
            this.onRejectedCallbacks.shift()(this.PromiseResult)
        }
    }

    then(onFulfilled, onRejected) {
        // 接收两个回调 onFulfilled, onRejected

        // 参数校验，确保一定是函数
        onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : val => val
        onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason }


        var thenPromise = new MyPromise((resolve, reject) => {

            const resolvePromise = cb => {
              setTimeout(() => {
                try {
                  const x = cb(this.PromiseResult)
                  if (x === thenPromise) {
                    // 不能返回自身哦
                    throw new Error('不能返回自身。。。')
                  }
                  if (x instanceof MyPromise) {
                    // 如果返回值是Promise
                    // 如果返回值是promise对象，返回值为成功，新promise就是成功
                    // 如果返回值是promise对象，返回值为失败，新promise就是失败
                    // 谁知道返回的promise是失败成功？只有then知道
                    x.then(resolve, reject)
                  } else {
                    // 非Promise就直接成功
                    resolve(x)
                  }
                } catch (err) {
                  // 处理报错
                  reject(err)
                  throw new Error(err)
                }
              })
            }

            if (this.PromiseState === 'fulfilled') {
                // 如果当前为成功状态，执行第一个回调
                resolvePromise(onFulfilled)
            } else if (this.PromiseState === 'rejected') {
                // 如果当前为失败状态，执行第二个回调
                resolvePromise(onRejected)
            } else if (this.PromiseState === 'pending') {
                // 如果状态为待定状态，暂时保存两个回调
                // 如果状态为待定状态，暂时保存两个回调
                this.onFulfilledCallbacks.push(resolvePromise.bind(this, onFulfilled))
                this.onRejectedCallbacks.push(resolvePromise.bind(this, onRejected))
            }
        })

        // 返回这个包装的Promise
        return thenPromise

    }
}

文章参考：

关于promise a+规范的梳理

一、promise A+规范

二、手写实现简易promise a+规范