自己实现一个Promise方法

 

  // Promise对象中
        // result结果：resolve和reject传的参数 就会作为结果
        class MyPromise {
            constructor(executor) {
                this._state = 'pending';
                this._result = 'undefined';
                this._fulfilledList = [];
                this._rejectedList = [];

                executor && executor(this.resolve.bind(this), this.reject.bind(this));
            }

            resolve(result) {
                if (this._state === 'pending') {
                    this._state = 'fulfilled';
                    this._result = result;
                    const fulfilled = this._fulfilledList.pop();
                    fulfilled && fulfilled(this._result);
                }
            }

            reject(error) {
                if (this._state === 'pending') {
                    this._state = 'rejected';
                    this._result = error;

                    const rejected = this._rejectedList.pop();
                    rejected && rejected(this._result);
                }
            }

            then(onfulfilled, onrejected) {
                // 如果状态为fulfilled
                if (this._state === 'fulfilled') {
                    return new MyPromise((resolve, reject) => {
                        // 获取onfulfilled的返回值
                        let result = onfulfilled(this._result);

                        // 如果发现返回值是Promise对象的实例 就做如下效果
                        if (result instanceof MyPromise) {
                            // 核心代码：把返回的new Promise的状态 和 result的状态进行关联跟着result的来
                            result.then(resolve, reject);
                        } else {
                            // 如果发现result是非promise对象 那就之间改变 new Promise的状态为fullfilled (通过调用resolve)
                            resolve(result);
                        }
                    });
                    // 如果状态是rejected
                } else if (this._state === 'rejected') {
                    return new MyPromise((resolve, reject) => {
                        let result = onfulfilled(this._result);

                        // 如果发现返回值是Promise对象的实例 就做如下效果
                        if (result instanceof MyPromise) {
                            // 核心代码：把返回的new Promise的状态 和 result的状态进行关联跟着result的来
                            result.then(resolve, reject);
                        } else {
                            // 如果发现result是非promise对象 那就之间改变 new Promise的状态为fullfilled (通过调用reject)
                            reject(result);
                        }
                    })
                } else if (this._state === 'pending') {
                    return new MyPromise((resolve, reject) => {
                        // 这个地方因为考虑到 实例中的状态还是pending 所以不能立即执行onfulfilled和onrejected
                        // 而是要把对于的代码 放在一个函数中，交由 this._fulfilled 中进行保存，在状态发生改变的地方 (如this.resolve方法中)
                        this._fulfilledList.push(() => {
                            // 这里面的逻辑 和上面的一样 获取onfulfilled的返回值
                            let result = onfulfilled(this._result);
                            // 如果发现返回值是Promise对象的实例 就做如下效果
                            if (result instanceof MyPromise) {
                                // 核心代码：把返回的new Promise的状态 和 result的状态进行关联跟着result的来
                                result.then(resolve, reject);
                            } else {
                                // 如果发现result是非promise对象 那就之间改变 new Promise的状态为fullfilled (通过调用resolve)
                                resolve(result);
                            }
                        });
                        this._rejectedList.push(() => {
                            let result = onrejected(this._result);

                            if (result instanceof MyPromise) {
                                result.then(resolve, reject);
                            } else {
                                // 1.hello
                                resolve(result);
                            }
                        });
                    })
                }
            }
        }

        let p = new MyPromise((resolve, reject) => {
            console.log('立即执行');
            // resolve('成功');
            // reject('失败');
            setTimeout(() => {
                reject('成功1');
            }, 1000)
        })
        console.log(p);
        p.then(data => {
            console.log(data);
            return 2;
        }, error => {
            console.log(error);
            return 4;
        }).then(data => {
            console.log(data);
            return new MyPromise((resolve) => {
                setTimeout(() => {
                    resolve(3);
                }, 1000)
            })
        }).then(data => {
            console.log(data);
        })