手写一个Promise

Charon

首先要确定Promise的几个特点

  1. Promise就是一个类,在执行这个类的时候需要传递一个执行器进去,执行器会立即执行
  2. Promise有三个状态,分别为 成功 fulfilled 失败 rejected 等待pending (pending=>fulfilled pending=>rejected) 一旦状态确定就不可更改
  3. resolve 和reject函数是用来更改状态的 resolve:fulfilled,reject:rejected
  4. then方法内部做的事情就是判断状态,如果状态是成功,就调用成功回调,如果是失败就调用失败回调,then方法被定义在原型对象里
  5. then成功回调有一个返回值,表示调用成功之后的值,失败回调也有一个返回值,表示失败的原因
  6. 同一个promise下的then可以调用多次的
  7. then方法是可以被链式调用的,后面then方法的回调函数拿到的值是上一个then方法的回调函数的返回值

以上就是Promise的主要部分,下面我们就根据这些特点来实现我们自己的promise

const PENDING = 'pending';
const FUFILLED = 'fufilled';
const REJECTED = 'rejected';
class MyPromise {
    status = PENDING;
    value = null;
    reason = null;
    successCallback = [];
    failCallback = [];
    constructor(executor) {//初始化的时候传进来的执行器
        try {
            executor(this.resolve, this.reject);//改变状态的俩函数,一个成功,一个失败
        } catch (error) {
            this.reject(err);//执行器出错的话,直接调用失败,改变当前promise的状态
        }
    }
    resolve = (value) => {//决议函数
        if (this.status !== PENDING) return;//如果状态不是等待,证明已经执行过了,为了符合promise一旦决议不可更改的特性,退出
        this.status = FUFILLED;//更改状态
        this.value = value;//保存一下决议值
        while (this.successCallback.length) this.successCallback.shift()();
        //如果执行器中代码是异步,并且绑定then函数时会把成功回调暂存起来,等执行器决议后调用通过then绑定的成功回调
        //当前这个promise可能会绑定多个then函数,所以成功回调用数组存放
    }
    reject = (reason) => {//失败状态函数
        if (this.status !== PENDING) return;//同上面的决议函数一样,调用过,退出
        this.reason = reason;//暂存失败原因,方便后续使用
        this.status = REJECTED;//修改状态
        while (this.failCallback.length) this.failCallback.shift()();
        //和resolve一样,不过这个是失败的数组,依次拿出来调用
    }
    then(successCallback, failCallback) {//then函数
        successCallback = successCallback ? successCallback : value => value;//成功参数可选,没有的话给个默认参数
        failCallback = failCallback ? failCallback : reason => { throw reason };
        //失败参数可选,没有的话给个默认手动抛错的函数,方便后续没传入的时候假如报错了,可以链式传递
        let promise2 = new MyPromise((resolve, reject) => {//声明promise,返回,符合then总是返回promise的规则
            if (this.status === FUFILLED) {//同步代码,成功了
                setTimeout(() => {///定时器添加是为了把这个函数修改为异步执行,等待promsie2同步执行完了,声明完毕后执行,这样才能获取到promise2
                    try {
                        let x = successCallback(this.value);//获取成功回调返回值
                        resolvePromise(promise2, x, resolve, reject);
                        //查看是否返回的是promise并且是否循环返回当前promise,如果是返回的promise展开他,并根据状态执行。如果是普通值,直接resolve
                    } catch (error) {
                        reject(error);//执行回调过程出错了,调用reject传递错误
                    }
                }, 0)
            } else if (this.status === REJECTED) {//同成功逻辑大体相似,不同是执行回调不一样,传入回调参数不一样
                setTimeout(() => {
                    try {
                        let x = failCallback(this.reason);
                        resolvePromise(promise2, x, resolve, reject);
                    } catch (error) {
                        reject(error);
                    }
                }, 0)
            } else {//上一个promsie执行器返回的不是立即值是一个异步操作
                this.successCallback.push(() => {//把这个成功回调暂存起来,等待当前promise resolve之后调用
                    setTimeout(() => {
                        try {
                            let x = successCallback(this.value);
                            resolvePromise(promise2, x, resolve, reject);
                        } catch (error) {
                            reject(error);
                        }
                    }, 0)
                })
                this.failCallback.push(() => {//把这个失败回调暂存起来,等待当前promise resolve之后调用
                    setTimeout(() => {
                        try {
                            let x = failCallback(this.reason);
                            resolvePromise(promise2, x, resolve, reject);
                        } catch (error) {
                            reject(error);
                        }
                    }, 0)
                })
            }
        })
        return promise2;
    }
    static all(array) {//promsie中的all方法  等待数组中所有项都完成后,在执行下一步 
        let result = []; //放完成结果
        let index = 0;//用来记录完成了几个
        return new MyPromise((resolve, reject) => {
            function addData(i, data) {//i是用来记录的下标防止顺序乱了,因为数组里有可能是立即值,有可能是promise,往reslut放的顺序有坑你不一致
                //data array数组项的执行结果
                result[key] = data;//放入
                index++;//标识加一
                if (index === result.length) {//相等全部完成了,往下走 resolve
                    resolve(result);
                }
            }
            for (let i = 0; i < array.length; i++) {
                //依次取出数组的项,查看是立即值还是promise,立即值的话直接添加到result数组里,promise的话展开它,成功了就添加到reslut里,失败了直接抛出reject,抛弃其他值
                let current = array[i];
                if (current instanceof MyPromise) {
                    current.then((value) => {
                        addData(i, value)
                    }, reason => { reject(reason) })
                } else {
                    addData(i, current)
                }
            }
        })
    }
    static resolve(value) {//遵循promise中resolve规范,如果传入是一个promise直接返回,如果不是用promise包i裹一层变成promise返回。 
        if (value instanceof MyPromise) return value;
        return new MyPromise((resolve) => resolve(value));
    }
    finally(callBack) {//先调用then返回promise,在它的回调里返回一个promise对象,然后调用callback并把它的返回值传递给promsie resolve方法,最后直接把当前promsie的成功值或失败值往后传递
        return this.then(() => {
            return MyPromise.resolve(callBack()).then(() => value);
        }, reason => {
            return MyPromise.resolve(callBack()).then(() => { throw reason });
        })
    }
    catch(failCallback) {//捕获错误方法,给当前返回的promsie通过then注册一个失败的回调,如果当前promise失败了就执行, 
        //是给返回promise注册的,每个then方法都会返回一个新的promise,如果前面某个链上的then返回的promsie有错误的话,并且没有使用错误回调捕获的话
        //我们会通过then默认错误回调,依次抛错,然后链式传递下来,知道被catch这个错误回调捕获
        return this.then(undefined, failCallback)
    }
    done(onFulfilled, onRejected) {
        //done代表promsie得结束,可以像then方法那样用,提供fulfilled和rejected状态的回调函数,也可以不提供任何参数。但不管怎样,done都会捕捉到任何可能出现的错误,并向全局抛出。
        this.then(onFulfilled, onRejected)
            .catch(function (reason) {
                // 抛出一个全局错误
                setTimeout(() => { throw reason }, 0);
            });
    }
}

function resolvePromise(promise2, x, resolve, reject) {//对比是否循环返回promsie的函数,判断返回的是promsie还是普通值得函数来进行下一步得调用
    if (x === promise2) {
        reject(new TypeError('Chaining cycle detected for promise #<Promise>'))
        return;
    }
    if (x instanceof MyPromise) {
        x.then(value => resolve(value), reason => reject(reason))
    } else {
        resolve(x);
    }
}

代码里的每一行都会有我的注释,有兴趣得同学可下载下来run一下,看看,自己读一读。

阅读 379

世界核平

34 声望
11 粉丝
0 条评论
你知道吗?

世界核平

34 声望
11 粉丝
宣传栏