手写Promise函数(未完待续)

1.promise是什么
2.自定义promise
想了解promise是什么,我们来按照官方文档写一个promise

var  promise1 = new Promise(function (success) {
        success("成功了");
    }, function (fail) {
      //  fail("失败了");
    })
    console.log(promise1);

    const promise2 = new Promise((success,fail)=>{
          //promise2调用了失败的回调函数
       // success("succsee");
        fail("fail");
    })
    console.log(promise2);

    promise1.then(function (success) {
        console.log("promise1:"+success);
    }, function fail(fial) {
        console.log("promise1:"+fial);
    })

    promise2.then(
        (success)=>{
            console.log("promise2:"+success);
        },
        (fail)=>{
            console.log("promise2:"+fail);
        },
    );

这段代码中,我定义了一个promise1和promise2的对象,传入了两个回调函数,分别是失败success和fail的函数,我们在浏览器中输入出promise实例,看看promise的结构
image.png
总体分为3个部分,promise对象的状态分为三个,

1.状态开始状态0,成功状态1和失败状态2,
2.内置函数success和fail,
3.原型方法then和catch

3.流程图
image.png
4.说明`
0 状态的 Promise 对象可能会变为1 状态并传递一个值给相应的状态处理方法, 也可能变为失败状态(2)并传递失败信息。当其中任一种情况出现时,Promise 对象的 then 方法绑定的处理方法(callbackFun )就会被调用(then方法包含两个参数:success 和 fail,它们都是 Function 类型。当Promise状态为1时,调用 then 的 successed方法,当Promise状态为2时,调用 then 的 failed 方法, 所以在异步操作的完成和绑定处理方法之间不存在竞争)

关键代码
`

function MunichPromise(callback) {
        var self = this;
        self.promiseStats = READYFLAG;//状态的属性,当调用成功的时候,改为1,当调用失败的时候,改为1
        self.promiseValue = null;//回调的时候的返回的时候
        self.promiseCallbacks = []; //用户自定义的回调函数(比如ajax返回时候,用户成功的时候,弹出成功提示,失败是弹出失败提示)
        //结构是{"success":function,"fail":fial}
        //定义内置函数--成功的回调(这个不暴露给用户使用)
        function success(value) {
            // var self = this;
            self.promiseStats = SUCCESSFLAG;
            self.promiseValue = value;
            setTimeout(() => {
                if (self.promiseCallbacks.length > 0) {
                    self.promiseCallbacks.forEach(item => {
                        item.successed(value);
                    });
                }
            }, 1);
        }
       
        function fail(reason) { //定义内置函数--失败的回调(这个不暴露给用户使用)
            //var self = this;
            self.promiseStats = FAILFLAG;
            self.promiseValue = reason;
            setTimeout(() => {
                if (self.promiseCallbacks.length > 0) {

                    self.promiseCallbacks.forEach(item => {
                        item.failed(reason);
                    });
                }
            }, 1);

        }
        callback(success, fail);
    }
    
MunichPromise.prototype.then = function (successed, failed) {
        var self = this;
        return new MunichPromise((success, fail) => {
            function callbackFun(callback) {
                let promise = callback(self.promiseValue);//调用成功或者失败
                if (promise instanceof Promise) {//如果返回的对象是promise
                    promise.then(//通过then拿到结果,继续递归
                        value => {
                            success(value);
                        },
                        reason => {
                            fail(reason);
                        }
                    )
                } else {
                    if (self.promiseStats == SUCCESSFLAG) {
                        success(self.promiseValue);//如果不是promise,直接返回结果
                    } else {
                        fail(self.promiseValue)
                    }
                }
            }

            if (self.promiseStats == READYFLAG) {//如果是第一次,把回调函数推进数组对象
                self.promiseCallbacks.push({
                    successed: (value) => {
                        callbackFun(successed)
                    },
                    failed: (reason) => {
                        callbackFun(failed)
                    }
                })
            } else if (self.promiseStats == SUCCESSFLAG) {
                callbackFun(successed)
            } else {
                callbackFun(failed)
            }
        })
    }`

评论

暂无评论