SOURCE

const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'
class VPromise {
    constructor(excutor) {
        this.status = PENDING
        this.value = undefined
        this.fulfilledQueues = []
        this.rejectedQueues = []

        try {
            excutor(this._resolve, this._reject)
        } catch (e) {
            this._reject(e)
        }
    }

    _resolve = value => {
        if (this.status === PENDING) {
            this.status = FULFILLED
            this.value = value
            let cb
            while (cb = this.fulfilledQueues.shift()) {
                cb(value)
            }
        }
    }

    _reject = reason => {
        if (this.status === PENDING) {
            this.status = REJECTED
            this.value = reason
            let cb
            while (cb = this.rejectedQueues.shift()) {
                cb(reason)
            }
        }
    }

    then(onFulfilled, onRejected) {
        const { status, value, fulfilledQueues, rejectedQueues } = this
        return new VPromise((_resolveNext, _rejectNext) => {
            let resolve = val => {
                if (typeof onFulfilled !== 'function') {
                    _resolveNext(val)
                } else {
                    let x = onFulfilled(val)
                    if (x instanceof VPromise) {
                        // 执行x，成功则调用
                        x.then(_resolveNext, _rejectNext)
                    } else {
                        _resolveNext(x)
                    }
                }
            }

            let reject = val => {
                if (typeof onRejected !== 'function') {
                    _rejectNext(val)
                } else {
                    let x = onRejected(val)
                    if (x instanceof VPromise) {
                        // 执行x，成功则调用
                        x.then(_resolveNext, _rejectNext)
                    } else {
                        _resolveNext(x)
                    }
                }
            }

            if (status === FULFILLED) {
                resolve(value)
            }
            if (status === REJECTED) {
                reject(value)
            }
            // 执行器是异步的情况，把回调放到回调队列里
            if (status === PENDING) {
                fulfilledQueues.push(resolve)
                rejectedQueues.push(reject)
            }
        })
    }
}

new VPromise(function (resolve, reject) {
    resolve('aa')
}).then(res => {
    console.log(1, res)
    return new VPromise((resolve1, reject1) => {
        resolve1('bb')
    })
}, err => {
    console.log(2, err)
}).then(res => {
    console.log(3, res)
}, err => {
    console.log(4, err)
})