设计模式（等待者模式）

      最近，闲来会看看《javascript设计模式》这本书，空闲时间我会把看到的写出来，和大家一起分享今天先来一个等待者模式。

      等待者模式：通过对异步进程监听，来触发未来发生的动作

      举例子：异步进程A,B，需要两个进程都完成以后才能进行C进程操作，这时可以使用等待者模式。

      平时在开发中经常会这样，需要等到上个程序完成或者知道上个程序完成才去触发下个程序，这时就可以等待者模式。说的不是很清楚咱们看代码：

      代码详情

      

           var Waiter = function() {
                    var dfd = [], //等待对象容器
                        doneArr = [], //成功回调容器
                        failArr = [], //失败回调容器
                        slice = Array.prototype.slice,
                        that = this;
                    //监控对象类
                    var Promise = function() {
                        //监控对象是否解决成功状态
                        this.resolved = false;
                        //监控对象是否解决失败状态
                        this.rejected = false;
                    }
                    Promise.prototype = {
                        //解决成功
                        resolve: function() {
                            //设置当前监控状态是成功
                            this.resolved = true;
                            if(!dfd.length) return;
                            console.log("进来");
                            //对象监控对象遍历如果任一个对象没有解决或者失败就返回
                            for(var i = dfd.length - 1; i >= 0; i--) {
                                if(dfd[i] && !dfd[i].resolved || dfd[i].rejected) {
                                    return;
                                }
                                dfd.splice(i, 1);
                            }
                            _exec(doneArr)
                        },
                        //解决失败
                        reject: function() {
                            //设置当前监控状态是失败
                            this.rejected = true;
                            //没有监控对象取消
                            if(!dfd.length) return;
                            //清楚监控对象
                            dfd.splice(0)
                            _exec(failArr)
                        }
                    }
                    that.Deferred = function() {
                        return new Promise();
                    };
                    //回调执行方法
                    function _exec(arr) {
                        var i = 0,
                            len = arr.length;
                        for(; i < len; i++) {
                            try {
                                arr[i] && arr[i]();
                            } catch(e) {}
                        }
                    };
                    //监控异步方法参数：监控对象
                    that.when = function() {
                        //设置监控对象
                        console.dir(arguments)
                        dfd = slice.call(arguments);
                        var i = dfd.length;
                        //向前遍历监控对象，最后一个监控对象索引值length-1
                        for(--i; i >= 0; i--) {
                            //不存在监控对象，监控对象已经解决，监控对象失败
                            if(!dfd[i] || dfd[i].resolved || dfd[i].rejected || !dfd[i] instanceof Promise) {
                                dfd.splice(i, 1)
                            }
                        }
                        //返回等待者对象
                        return that;
                    };
                    //解决成功回调函数添加方法
                    that.done = function() {
                        //向成功毁掉函数容器中添加回调方法
                        doneArr = doneArr.concat(slice.call(arguments));
                        return that;
                    };
                    //解决失败回调函数添加方法
                    that.fail = function() {
                        //向失败回调函数中添加方法
                        failArr = failArr.concat(slice.call(arguments));
                        return that;
                    };
                }

         测试：

         var waiter = new Waiter();//创建一个等待者实例
                var first = function() {
                    var dtd = waiter.Deferred();
                    setTimeout(function() {
                        dtd.resolve();
                    }, 5000)
                    return dtd;//返回监听这对象
                }()
                var second = function() {//第二个对象
                    var dtd = waiter.Deferred();
                    setTimeout(function() {
                        dtd.resolve();
                    }, 10000)
                    return dtd;
                }()
                waiter.when(first, second).done(function() {
                    console.log("success")
                }, function() {
                    console.log("success again")
                }).fail(function() {
                    console.log("fail")
                })

   结果

     

    总结：通过创建不同的监听对象，判断对象状态调用失败或者成功的回调函数