Promise 封装

// 声明构造函数
    function Promise(executor) {
        // 添加默认值
        this.PromiseState = 'Pending';
        this.PromiseRestult = '';
        // 接受多个 then 链式调用
        this.callbacks = [];
        const self = this;
        // resolve 函数
        function resolve(data) {

            if (self.PromiseState !== 'pending') return;
            // 修改对象的状态
            self.PromiseState = 'fulfilled';
            // 设置对象结果的值
            self.PromiseResult = data;
            // 执行成功的回调
            self.callbacks.forEach(item => {
                item.onResolved(data)
            })
        }

        // reject 函数
        function reject(data) {
            if (self.PromiseState !== 'pending') return;
            // 修改对象的状态
            self.PromiseState = 'rejected';
            // 设置对象结果的值
            self.PromiseResult = data;
            self.callbacks.forEach(item => {
                item.onRejected(data)
            })
        }
        // 声明执行器函数
        try {
            executor(resolve, reject);
        } catch (e) {
            reject(e)
        }
    }

    // 添加 then 方法
    Promise.prototype.then = function (onResolved, onRejected) {
        const self = this;
        return new Promise((resolve, reject) => {
            // 封装函数
            function callbacks(params) {
                try {
                    let result = params(self.PromiseResult);
                    if (result instanceof Promise) {
                        result.then(v => {
                            resolve(v)
                        },r => {
                            reject(r)
                        }),
                    } else {
                        resolve(result)
                    }
                } catch (e) {
                    reject(e)
                }
            } 

            // 调用回调函数
            if (this.PromiseState === 'fulfilled') {
                callback(onResolved)
            }
            if (this.PromiseState === 'rejected') {
                callback(onRejected)
            }

            // 判断 pending 状态
            if (this.PromiseState === 'pending') {
                // 保存回调函数
                this.callback.push({
                    onResolved() {
                        callback(onResolved)
                    },
                    onRejected() {
                        callback(onRejected)
                    }
                })
            }
        })
    }

    let p = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('ok')
            reject('err')
            // throw "error"
        }, 1000);
    })
    const res = p.then(value => {
        console.log(value);
        // return "oh yee"
        // throw "error"
    }, reason => {
        throw "error"
        // console.warn(reason);
    })
    console.log(res);

参考

promise函数封装（完整版）_Danny-CSDN博客_promise封装