Promise及 API 模拟实现

本文章也发布在掘金,附上地址:https://juejin.im/post/5de635865188251274248dba

Promise的实现首先分为三部分:

    • promise的状态控制

    • promise的后续处理

    • Promise的串联

promise的API分为原型成员(实例成员)和构造函数成员(静态成员)

  • 原型成员

    • then:注册一个后续处理函数,当Promise为resolved状态时运行该函数

    • catch: 注册一个后续处理函数,当Promise为rejected状态时运行该函数

    • finally:[ES2018]注册一个后续处理函数(无参),当Promise为已决时运行该函数

  • 构造函数成员

    • resolve(数据):该方法返回一个resolved状态的Promise,传递的数据作为状态数据,如果传递的数据是Promise,则直接返回传递的Promise对象

    • reject(数据):该方法返回一个rejected状态的Promise,传递的数据作为状态数据

    • all(iterable):这个方法返回一个新的promise对象,该promise对象在iterable参数对象里所有的promise对象都成功的时候才会触发成功,一旦有任何一个iterable里面的promise对象失败则立即触发该promise对象的失败。这个新的promise对象在触发成功状态以后,会把一个包含iterable里所有promise返回值的数组作为成功回调的返回值,顺序跟iterable的顺序保持一致;如果这个新的promise对象触发了失败状态,它会把iterable里第一个触发失败的promise对象的错误信息作为它的失败错误信息。Promise.all方法常被用于处理多个promise对象的状态集合。

    • race(iterable):当iterable参数里的任意一个子promise被成功或失败后,父promise马上也会用子promise的成功返回值或失败详情作为参数调用父promise绑定的相应句柄,并返回该promise对象


Promise状态控制实现

const MyPromise = (()=>{
    const PENDING = "pending",
          RESOLVED = "resolved",
          REJECTED = "rejected",
          PromiseStatus = Symbol("PromiseStatus"),
          PromiseValue = Symbol("PromiseValue"),
          changeStatus = Symbol("changeStatus");          
    return class MyPromise{
        /**
         * 改变当前Promise的状态
         * @param {*} newStatus 
         * @param {*} newValue 
         * @param {*} queue 
         */
        [changeStatus](newStatus,newValue){            
            if(this[PromiseStatus !==PENDING]){                
                return;
            }
            this[PromiseStatus] = newStatus;
            this[PromiseValue] = newValue;
        }      
        
        constructor(executor){
            this[PromiseStatus] = PENDING;
            this[PromiseValue] = undefined;
            const resolve = data =>{
                this[changeStatus](RESOLVED,data)
            }
            const reject = err =>{
                this[changeStatus](REJECTED,err)
            }
            try{
            //实例化一个新的promise对象时会传递一个函数,该函数带有resolve和reject两个形参,并且会自动调用该函数
                executor(resolve,reject);
            }catch(err){
                this[changeStatus](REJECTED,err)
            }
        }
    }
})()

promise状态控制实现: 首先实例化一个promise对象时,需要传递一个函数,该函数带有两个形参resolve,reject, 在实例化过程中会自动调用该函数(executor),执行传递的函数,实例化后得到promise对象带有两个属性,PromiseStatue,promiseValue, 当在该函数的执行体内调用executor的参数时(resolve,reject),会执行构造函数内相应的函数


+Promise的后续处理

const MyPromise = (() => {
    const PENDING = "pending",
        RESOLVED = "resolved",
        REJECTED = "rejected",
        PromiseStatus = Symbol("PromiseStatus"),
        PromiseValue = Symbol("PromiseValue"),
        changeStatus = Symbol("changeStatus"),
        //新增
        thenables = Symbol("thenables"),
        catchables = Symbol("catchables"),
        settleHandler = Symbol('settleHandler')    
    return class MyPromise {
        [changeStatus](newStatus, newValue,queue) {            
            if (this[PromiseStatus !== PENDING]) {                
                return;
            }
            this[PromiseStatus] = newStatus;
            this[PromiseValue] = newValue;
            //执行相应队列中的函数
            queue.forEach(handler =>handler(newValue))
            //这里会执行调用then/catch方法时还未达到已决状态时放入作业队列中的后续处理函数

        }

        constructor(executor) {
            this[PromiseStatus] = PENDING;
            this[PromiseValue] = undefined;
            //新增
            this[thenables] = [];
            this[catchables] = [];
            const resolve = data => {
                //修改
                this[changeStatus](RESOLVED, data,this[thenables])
            }
            const reject = err => {
                //修改
                this[changeStatus](REJECTED, err,this[catchables])
            }
            try {
                //实例化一个新的promise对象时会传递一个函数,该函数带有resolve和reject两个形参,并且会自动调用该函数
                executor(resolve, reject);
            } catch (err) {
                //修改
                this[changeStatus](REJECTED, err,this[catchables])
            }
        }
        
        /**新增
         * promise的后续函数
         * @param {*} handler 后续处理函数
         * @param {*} immediatelyStatus 需要立即执行的状态
         * @param {*} queue 作业队列
         */
        [settleHandler](handler,immediatelyStatus,queue){            
            if(this[PromiseStatus] === immediatelyStatus){                
                setTimeout(()=>{
                    handler(this[PromiseValue])
                })
            }else{
                queue.push(handler)
            }
        }
        
        /**新增
         * Promise原型上的then方法
         * @param {*} thenable then的处理函数
         * @param {*} catchable catch的处理函数,如果传递了话
         */        
         then(thenable, catchable) {
            this[settleHandler](thenable,RESOLVED,this[thenables]);
            this.catch(catchable);//该函数也会执行,但过不了settleHandler状态的一关,自然执行不了catch的后续处理函数
        }

        /**新增
         * Promise原型上的catch方法
         * @param {*} catchable catch的处理函数
         */
        catch(catchable) {
            this[settleHandler](catchable,REJECTED,this[catchables]);
        }
    }
})()

then,catch后续处理: 当调用then/catch方法时,then会接受2个后续处理函数(thenable和catchable),catch会接收一个后续处理函数(catchable) ,如果此时状态处于未决阶段时,会把后续处理函数放入到作业队列里(微队列),等到变成已决阶段时才会从作业队列里按排列顺序(changeStatue中执行)执行作业队列里面的后续处理函数 ,如果此时状态已经处于已决阶段,会直接运行该后续处理函数,如果还是处于未决阶段时(参数数据均来自已决阶段得到的数据)


+Promise的串联

const MyPromise = (() => {
    const PENDING = "pending",
        RESOLVED = "resolved",
        REJECTED = "rejected",
        PromiseStatus = Symbol("PromiseStatus"),
        PromiseValue = Symbol("PromiseValue"),
        changeStatus = Symbol("changeStatus"),
        thenables = Symbol("thenables"),
        catchables = Symbol("catchables"),
        settleHandler = Symbol('settleHandler'),
        linkPromise = Symbol('linkPromise')    
    return class MyPromise {
        [changeStatus](newStatus, newValue,queue) {            
            if (this[PromiseStatus !== PENDING]) {                
                return;
            }
            this[PromiseStatus] = newStatus;
            this[PromiseValue] = newValue;
            //执行相应队列中的函数
            queue.forEach(handler =>handler(newValue))
            //这里会执行调用then/catch方法时还未达到已决状态时放入作业队列中的后续处理函数

        }

        constructor(executor) {
            this[PromiseStatus] = PENDING;
            this[PromiseValue] = undefined;
            this[thenables] = [];
            this[catchables] = [];
            const resolve = data => {
                this[changeStatus](RESOLVED, data,this[thenables])
            }
            const reject = err => {
                this[changeStatus](REJECTED, err,this[catchables])
            }
            try {
                //实例化一个新的promise对象时会传递一个函数,该函数带有resolve和reject两个形参,并且会自动调用该函数
                executor(resolve, reject);
            } catch (err) {
                this[changeStatus](REJECTED, err,this[catchables])
            }
        }
        
        /**
         * promise的后续函数
         * @param {*} handler 后续处理函数
         * @param {*} immediatelyStatus 需要立即执行的状态
         * @param {*} queue 作业队列
         */
        [settleHandler](handler,immediatelyStatus,queue){            
            if(typeof handler !== 'function'){                
                return;
            }            
            if(this[PromiseStatus] === immediatelyStatus){                
                setTimeout(()=>{
                    handler(this[PromiseValue])
                })
            }else{
                queue.push(handler)
            }
        }
        
        /**新增
        * promise的串联:then/catch方法被调用后首先调用该函数,生成一个新的Promise对象并返回,
        * 然后then/catch为了要确认自身状态,需要调用settleHandler查看后续处理函数的运行状况,(通过接收运行返回的结果),如果返回的结果是一个可以按照正常逻辑走下去的非promise对象
        ,则then方法返回的新Promise状态为resolved,如果是一个不能按照正常逻辑走下去的非Promise对象,则then方法返回的新Promise状态为rejected,如果返回的是一个promise对象,
        新promise状态与该Promise状态的then方法返回的后续处理函数执行情况保持一致
        * @param {*} thenalbe //then的后续处理函数
        * @param {*} catchable //catch的后续处理函数
        */
        [linkPromise](thenable, catchable){            
            function exec(data,handler,resolve,reject){
                try{
                    const result = handler(data)//得到的result是后续处理函数返回的结果                    
                    if(result instanceof MyPromise){
                        result.then(d=>{
                            resolve(d)
                        },err=>{
                            reject(err)
                        })
                    }else{
                        resolve(result)
                    }
                }catch(err){
                    reject(err)
                }
            }            
            return new MyPromise((resolve,reject)=>{
                this[settleHandler](data=>{                    
                exec(data,thenable,resolve,reject);
                },RESOLVED,this[thenables])
                this[settleHandler](reason=>{                    
                exec(reason,catchable,resolve,reject);
                },REJECTED,this[catchables])
            })
        }
        
        /**修改
         * Promise原型上的then方法
         * @param {*} thenable then的处理函数
         * @param {*} catchable catch的处理函数,如果传递了话
         */        
         then(thenable, catchable) {           
             return this[linkPromise](thenable,catchable);
         }

        /**修改
         * Promise原型上的catch方法
         * @param {*} catchable catch的处理函数
         */
        catch(catchable) {           
            return this[linkPromise](undefined,catchable);
        }
    }
})()


3.串联Promise: 应用场景:当后续的Promise需要用到之前的Promise的处理结果时,需要Promise的串联

promise对象中,无论是then方法还是catch方法,他们都具有返回值,返回的是一个全新的promise对象(return new Promise),该Promise的状态取决于后续处理函数, 如果该后续处理函数还没执行,还在作业队列里,则返回的Promise的状态是挂起状态(pandding),如果该后续处理函数已经在执行,说明该then自身的Promise对象进入了 已决状态(resolve或reject),如果后续处理函数能顺利执行,并返回了值,则then方法创建的全新Promise的状态变为Resolve,(参数数据为then方法return回来的数据) 如果后续处理函数在执行过程中发生了错误,(有报错),则该全新的Promise进入reject状态,(参数数据为报错的数据) 如果前面的Promise的后续处理函数在能顺利执行后,返回的值是一个Promise对象,则返回的新的Promise状态和后续处理返回的Promise状态保持一致, 注意并不是跟返回的Promise的后续处理函数执行状态保持一致(意思就是状态重新配对 return 的promise对象的状态,之前的无效) (参数来自 已决阶段的后续处理函数返回的参数)


至此,Promsie的功能基本实现。



const MyPromise = (() => {
    const PENDING = "pending",
        RESOLVED = "resolved",
        REJECTED = "rejected",
        PromiseStatus = Symbol("PromiseStatus"),
        PromiseValue = Symbol("PromiseValue"),
        changeStatus = Symbol("changeStatus"),
        thenables = Symbol("thenables"),
        catchables = Symbol("catchables"),
        settleHandler = Symbol('settleHandler'),
        linkPromise = Symbol('linkPromise')    
    return class MyPromise {
        [changeStatus](newStatus, newValue,queue) {            
            if (this[PromiseStatus !== PENDING]) {                
                return;
            }
            this[PromiseStatus] = newStatus;
            this[PromiseValue] = newValue;
            //执行相应队列中的函数
            queue.forEach(handler =>handler(newValue))
            //这里会执行调用then/catch方法时还未达到已决状态时放入作业队列中的后续处理函数

        }

        constructor(executor) {
            this[PromiseStatus] = PENDING;
            this[PromiseValue] = undefined;
            this[thenables] = [];
            this[catchables] = [];
            const resolve = data => {
                this[changeStatus](RESOLVED, data,this[thenables])
            }
            const reject = err => {
                this[changeStatus](REJECTED, err,this[catchables])
            }
            try {
                //实例化一个新的promise对象时会传递一个函数,该函数带有resolve和reject两个形参,并且会自动调用该函数
                executor(resolve, reject);
            } catch (err) {
                this[changeStatus](REJECTED, err,this[catchables])
            }
        }
        
        /**
         * promise的后续函数
         * @param {*} handler 后续处理函数
         * @param {*} immediatelyStatus 需要立即执行的状态
         * @param {*} queue 作业队列
         */
        [settleHandler](handler,immediatelyStatus,queue){            
            if(typeof handler !== 'function'){                
                return;
            }            
            if(this[PromiseStatus] === immediatelyStatus){                
                setTimeout(()=>{
                    handler(this[PromiseValue])
                })
            }else{
                queue.push(handler)
            }
        }
        
        /**新增
        * promise的串联:then/catch方法被调用后首先调用该函数,生成一个新的Promise对象并返回,
        * 然后then/catch为了要确认自身状态,需要调用settleHandler查看后续处理函数的运行状况,(通过接收运行返回的结果),如果返回的结果是一个可以按照正常逻辑走下去的非promise对象
        ,则then方法返回的新Promise状态为resolved,如果是一个不能按照正常逻辑走下去的非Promise对象,则then方法返回的新Promise状态为rejected,如果返回的是一个promise对象,
        新promise状态与该Promise状态的then方法返回的后续处理函数执行情况保持一致
        * @param {*} thenalbe //then的后续处理函数
        * @param {*} catchable //catch的后续处理函数
        */
        [linkPromise](thenable, catchable){            
            function exec(data,handler,resolve,reject){
                try{
                    const result = handler(data)//得到的result是后续处理函数返回的结果                    
                    if(result instanceof MyPromise){
                        result.then(d=>{
                            resolve(d)
                        },err=>{
                            reject(err)
                        })
                    }else{
                        resolve(result)
                    }
                }catch(err){
                    reject(err)
                }
            }            
            return new MyPromise((resolve,reject)=>{
                this[settleHandler](data=>{                    
                exec(data,thenable,resolve,reject);
                },RESOLVED,this[thenables])
                this[settleHandler](reason=>{                    
                exec(reason,catchable,resolve,reject);
                },REJECTED,this[catchables])
            })
        }
        
        /**修改
         * Promise原型上的then方法
         * @param {*} thenable then的处理函数
         * @param {*} catchable catch的处理函数,如果传递了话
         */        
         then(thenable, catchable) {           
             return this[linkPromise](thenable,catchable);
         }

        /**修改
         * Promise原型上的catch方法
         * @param {*} catchable catch的处理函数
         */
        catch(catchable) {           
            return this[linkPromise](undefined,catchable);
        }
    }
})()



其他API

  1. Promise.resolve()

static resolve(data){    
    if(data instanceof Mypromise){        
        return data
    }else{        
        return new MyPromise((resolve,reject)=>{
        resolve(data);
        })
    }
}

静态resolve方法,静态resolve方法接受一个参数,如果该参数不是Promise对象,返回一个resolve状态的新Promise 如果该参数是一个promise对象,直接返回该promise对象



    2. Promise.reject()

static reject(reason){
    //写两个参数是因为这这是形参,真正的reject在第二位参数位置    
    return new MyPromise((resolve,reject)=>{
        reject(reason)
    })
}

静态reject方法:接收一个参数,返回一个reject状态的Promise对象


    3. Promise.race()

static race(proms){    
    return new Promise((resolve,reject)=>{
        proms.forEach(pro=>{
            pro.then(data=>{
                resolve(data);
            },err=>{
                reject(err);
            })
        })
    })
}

静态race方法:接受一个由promise对象组成的数组,返回一个首先到达已决阶段的promise对象


    4. Promise.all()

static all(proms) {    
   return new Promise((resolve, reject) => {
        const results = proms.map(p => {
            const obj = {
                result: undefined,
                isResolved: false
            }
            p.then(data => {
                obj.result = data;
                obj.isResolved = true;
                //判断是否所有的全部完成
                const unResolved = results.filter(r => !r.isResolved)                      
                if (unResolved.length === 0) {
                    //全部完成
                    resolve(results.map(r => r.result));
                }
            }, reason => {
                reject(reason);
            })            
            return obj;
        })
    })
}

标签:

评论 抢沙发

表情
首页上一页12下一页尾页