Promise 自定义封装

function Promise(executor) {
    // 定义promise中的属性
    this.PromiseState = 'pending'
    this.PromiseResult = null
    //存放then方法中的回调
    this.callbacks = []
    //定义this指向
    const self = this
    // 定义成功方法
    function resolve(data) {
        //判断此时的状态
        if (self.PromiseState !== 'pending') return
        self.PromiseState = 'fulfilled'
        self.PromiseResult = data
        setTimeout(() => {
            self.callbacks.forEach(item => {
                item.onResolved(data)
            })
        })
    }
    //定义失败方法
    function reject(data) {
        //判断此时的状态
        if (self.PromiseState !== 'pending') return
        self.PromiseState = 'rejected'
        self.PromiseResult = data
        setTimeout(() => {
            self.callbacks.forEach(item => {
                item.onRejected(data)
            })
        })
    }
    try {
        executor(resolve, reject)
    } catch (error) {
        reject(error)
    }
}
Promise.prototype.then = function (onResolved, onRejected) {
    //定义this指向
    const self = this
    //判断onResolved
    if (typeof onResolved !== 'function') {
        onResolved = value => value
    }
    //判断onRejected
    if (typeof onRejected !== 'function') {
        onRejected = reason => {
            throw reason
        }
    }
    //then方法会返回一个promise对象
    return new Promise((resolve, reject) => {
        //封装回调函数
        function callback(type) {
            try {
                let result = type(self.PromiseResult)
                //判断结果
                if (result instanceof Promise) {
                    result.then(value => {
                        resolve(value)
                    }, reason => {
                        reject(reason)
                    })
                } else {
                    resolve(result)
                }
            } catch (error) {
                reject(error)
            }
        }
        //状态为fulfilled时
        if (this.PromiseState == 'fulfilled') {
            setTimeout(()=>{
                callback(onResolved)
            })
        }
        //状态为rejected时
        if (this.PromiseState == 'rejected') {
            setTimeout(()=>{
                callback(onRejected)
            })
        }
        //状态为pending时
        if (this.PromiseState == 'pending') {
            this.callbacks.push({
                onResolved: function () {
                    callback(onResolved)
                },
                onRejected: function () {
                    callback(onRejected)
                }
            })
        }
    })
}