https://juejin.im/post/5b2f02cd5188252b937548ab  详解

https://juejin.im/post/5cd8d76d5188256805093a9f

//Promise函数

function Promise(executor) {

    let self = this; //保留this。防止后面方法出现this只想不明的问题

    self.status = 'pending'; //promise的默认状态是pending

    self.value= undefined; //保存成功回调传递的值

    self.error = undefined; //保存失败回调传递的值

    self.onSuccessCallbacks = []; //存放成功的回调

    self.onErrorCallbacks = []; //存放失败的回调

    function resolve(value) {

        if (self.status === 'pending') {

            self.status = 'resolved'; //成功函数将其状态修改为resolved

            self.value= value; //将成功的值保存起来

            self.onSuccessCallbacks.forEach(fn=> {

                fn();

            });

        }

    }

    function reject(error) {

        if (self.status === 'pending') {

            self.status = 'rejected'; //失败函数将其函数修改为rejected

            self.error = error; //将失败的值保存起来

            self.onErrorCallbacks.forEach(fn=> {

                fn();

            })

        }

    }

    try {

        executor(resolve, reject);

    } catch (err) {

        reject(err);

    }

}

//then函数

Promise.prototype.then = function (onResolved, onRejected) {

    let self = this;

    let promiseAgain = new Promise((resolve, reject) => {

        if (self.status === 'pending') {

            self.onSuccessCallbacks.push(() => {

                    let x = onResolved(self.value); //将resolve函数保留的成功值传递作为参数

                    resolvePromise(promiseAgain, x, resolve, reject);

            })

            self.onErrorCallbacks.push(() => {

                    let x = onRejected(self.error); //将reject函数保留的失败值传递作为参数

                    resolvePromise(promiseAgain, x, resolve, reject);

            })

        }

        if (self.status === 'resolved') {

                let x = onResolved(self.value); //将resolve函数保留的成功值传递作为参数

                resolvePromise(promiseAgain, x, resolve, reject);

        }

        if (self.status === 'rejected') {

                let x = onRejected(self.error); //将reject函数保留的失败值传递作为参数

                resolvePromise(promiseAgain, x, resolve, reject);

        }

    })

    return promiseAgain;

}

//resolvePromise函数

function resolvePromise(promiseAgain, x, resolve, reject) {

    if (promiseAgain === x) {

        return reject(new TypeError("循环调用"));

    }

    if (x !== null && (typeof x === 'object' || typeof x === 'function')) {

        try {

            let then = x.then;

            if (typeof then === 'function') {

                then.call(x, (y) => {

                    resolvePromise(promiseAgain, y, resolve, reject);

                }, (e) => {

                    reject(e);

                })

            } else {

                resolve(x);

            }

        } catch (error) {

            reject(error);

        }

    } else {

        resolve(x);

    }

}

module.exports = Promise;