手写Promise

// An highlighted block
function Promise(executor) {
    /*
        Promise: 构造函数
        excutor: 执行器函数(同步回调函数)
    */
    this.status = 'preding' // 给promise对象指定status属性，初始值为prending
    this.data = undefined //给promise对象指定一个用于存储结果数据的属性
    const self = this // 保存实例对象的this的值
    this.callbacks = []// 每一个元素的结构:{onResolved(){},onRejected() {}}
    // Promise实例对象的resolve
    // 返回一个指定成功的promise
    function resolve(value) {
        // 如果当前状态不是Prending,直接结束
        if (self.status != 'preding') {
            return
        }
        //改变状态
        self.status = 'resolved'
        //保存异步操作得到的value数据
        self.data = value
        // 执行onResolve回调函数
        setTimeout(() => {
            self.callbacks.forEach(item => {
                item.onResolved(value)
            })
        })
    }
    // Promise实例对象的reject
    // 返回一个指定失败的promise
    function reject(reason) {
        // 如果当前状态不是Prending,直接结束
        if (self.status != 'preding') {
            return
        }
        //改变状态
        self.status = 'rejected'
        //保存value数据
        self.data = reason
        // 执行onRejected回调函数
        setTimeout(() => {
            self.callbacks.forEach(item => {

                item.onRejected(reason)
            })
        })
    }

    // 执行回调函数
    try {
        // 同步调用 [执行器函数]
        executor(resolve, reject)
    } catch (error) {
        // 修改promise对象状态为失败
        return reject(error)
    }
}


// Promise原型对象的then()
// 指定成功和失败的回调函数
// 返回一个新的Promise对象
Promise.prototype.then = function (onResolved, onRejected) {
    const self = this
    // 判断回调函数参数
    if (typeof onRejected != 'function') {
        onRejected = reason => {
            throw reason;
        }
    } // 考虑异常穿透,没有指定reject,初始化reject为异常
    if (typeof onResolved != 'function') {
        onResolved = value => value
    } // 默认省略resolve,reject回调,初始化resolve,then也可以继续往下传
    return new Promise((resolve, reject) => {
        // 封装函数
        function callBack(onFun) {
            try {
                // 获取回调函数执行结果 
                let result = onFun(self.data)
                //判断 结果是否是Promise对象
                if (result instanceof Promise) {
                    result.then(v => {
                        resolve(v)
                    }, r => {
                        reject(r)
                    })
                } else {//不是直接成功
                    //状态为成功
                    resolve(result)
                }
            } catch (error) {
                reject(error)
            }
        }
        // 调用回调函数 
        if (this.status === 'resolved') {
            setTimeout(() => {
                callBack(onResolved)
            })
        }
        if (this.status === 'rejected') {
            setTimeout(() => {
                callBack(onRejected)
            })
        }
        // 改变状态前,绑定回调函数
        if (this.status === 'preding') {
            // 保存回调函数
            this.callbacks.push({
                onResolved: () => callBack(onResolved),
                onRejected: () => callBack(onRejected)
            })
        }
    })
}
// // Promise原型对象的catch()
// // 指定失败的回调函数
// // 返回一个新的Promise对象 
Promise.prototype.catch = function (onRejected) {
    return this.then(undefined, onRejected)
}

// Promise函数对象的resolve
// 返回一个指定成功的promise
Promise.resolve = function (value) {
    //返回一个promise对象
    return new Promise((resolve, reject) => {
        if (value instanceof Promise) {
            value.then(v => {
                resolve(v)
            }), r => {
                reject(r)
            }
        } else {
            resolve(value)
        }
    })
}

// Promise函数对象的reject
// 返回一个指定失败的promise
Promise.reject = function (reason) {
    return new Promise((resolve, reject) => {
        reject(reason)
    })
}

// Promise函数对象all (成功返回promise数组,数组的返回值严格对应输入的顺序)
// 返回一个promise,只有当所有promise都成功菜成功，否则只要一个失败就是失败
Promise.all = function (promises) {
    //返回结果为promise对象
    return new Promise((resolve, reject) => {
        // 声明变量
        let count = 0
        let arr = []
        for (let i = 0; i < promises.length; i++) {
            promises[i].then(v => {
                // 得知对象的状态是成功
                // 每个promise对象 都成功才修改返回Promise的状态
                count++
                arr[i] = v
                if (count == promises.length) {
                    resolve(arr)
                }
            }, r => {
                // 有一个失败就修改Promise的状态
                reject(r)
            })
        }
    })
}

// Promise函数对象race
// 返回一个promise,其结果由第一个完成的promise决定
Promise.race = function (promises) {
    return new Promise((resolve, reject) => {
        for (let i = 0; i < promises.length; i++) {
            promises[i].then(v => {
                resolve(v)
            }, r => {
                reject(r)
            }
            )
        }
    })
}