自定义封装Promise对象

自定义封装Promise对象

//声明构造函数
function selfPromise(executor) {
    //添加属性
    this.promiseState = "pending";
    this.promiseResult = null;
    //用于保存回调函数
    this.callbacks = [];
    const self = this;
    //resolve函数
    function resolve(data) {
        //确保promiseState只能修改一次
        if (self.promiseState !== "pending") return;
        //1.修改对象的状态(promiseState)
        self.promiseState = "fulfilled"; //resolved
        //2.设置对象的结果(promiseResult)
        self.promiseResult = data;
        //定时器确保回调函数异步执行
        setTimeout(() => {
            //3.调用成功的回调函数
            self.callbacks.forEach(item => {
                item.onResolved(data);
            })
        })
    };
    //reject函数
    function reject(data) {
        //确保promiseState只能修改一次
        if (self.promiseState !== "pending") return;
        //1.修改对象的状态(promiseState)
        self.promiseState = "rejected"; //resolved
        //2.设置对象的结果(promiseResult)
        self.promiseResult = data;
        //定时器确保回调函数异步执行
        setTimeout(() => {
            // 3.调用失败的回调函数 
            self.callbacks.forEach(item => {
                item.onRejected(data);
            })
        })
    };
    //同步调用【执行器函数】
    try {
        executor(resolve, reject);
    } catch (e) {
        //修改selfPromise对象状态为失败(实现 throw "error"功能)
        reject(e);
    }
}

//添加then方法
selfPromise.prototype.then = function (onResolved, onRejected) {
    const self = this;
    //判断回调函数的参数
    if (typeof onRejected !== 'function') {
        onRejected = season => {
            throw season;
        }
    }
    if (typeof onResolved !== 'function') {
        onResolved = value => value;
    }
    return new Promise((resolve, reject) => {
        //封装回调
        function callback(type) {
            try {
                let result = type(self.promiseResult);
                if (result instanceof selfPromise) {
                    result.then(v => {
                        resolve(v);
                    }, r => {
                        reject(r);
                    });
                } else {
                    resolve(result);
                }
            } catch (e) {
                reject(e)
            }
        }
        //根据promiseState调用成功/失败的回调函数
        if (this.promiseState === "fulfilled") {
            //确保回调函数异步执行
            setTimeout(() => { callback(onResolved); })
        }
        if (this.promiseState === "rejected") {
            //确保回调函数异步执行
            setTimeout(() => { callback(onRejected); })
        }
        //判断pending的状态
        if (this.promiseState = "pending") {
            //保存回调函数
            this.callbacks.push({
                onResolved: function () {
                    callback(onResolved)
                },
                onRejected: function () {
                    callback(onRejected);
                }
            });
        }
    })
}

//添加catch方法
selfPromise.prototype.catch = function (onRejected) {
    return this.then(undefined, onRejected);
}

//添加resolve方法
selfPromise.resolve = function (value) {
    //返回一个Promise对象
    return new selfPromise((resolve, reject) => {
        if (value instanceof selfPromise) {
            value.then(v => {
                resolve(v);
            }, r => {
                reject(r);
            });
        } else {
            resolve(value);
        }
    });
}

//添加reject方法
selfPromise.reject = function (reason) {
    //返回一个Promise对象
    return new selfPromise((resolve, reject) => {
        reject(reason);
    });
}

//添加all方法
selfPromise.all = function (promises) {
    //返回一个Promise对象    
    return new selfPromise((resolve, reject) => {
        let count = 0;
        let arr = [];
        //遍历检测
        for (let i = 0; i < promises.length; i++) {
            promises[i].then(v => {
                //得知对象的状态是成功的
                //每个promise对象都成功
                count++;
                arr[i] = v;
                if (count === promises.length) {
                    resolve(arr);
                }
            }, r => {
                reject(r);
            });
        }
    });
}

//添加race方法
selfPromise.race = function (promises) {
    //返回一个Promise对象    
    return new selfPromise((resolve, reject) => {
        //遍历检测
        for (let i = 0; i < promises.length; i++) {
            promises[i].then(v => {
                resolve(v);
            }, r => {
                reject(r);
            });
        }
    });
}