小练习—FuncDelayer—JS函数延迟器

(function(window){
    /* === Class DelayedFunc begin === */
    /*
    用 DelayedFunc 类创建的对象包含5属性
    func 【function】 需要触发的函数实体
    allowCount 【int】 已经成功触发的条件数
    conditionCount 【int】 需要触发的条件数
    allowFlag 【bool】 该函数的所有触发条件都已经触发了，其值就为true，否则其值就为false
    conditionStatusList 【Obj】 此对象包含的子属性的数目将等于conditionCount的值，这n个属性的属性名和触发条件名相同
    */
    var DelayedFunc = function(func, conditionCount){
        var _this = this;
        _this.func = func;
        _this.conditionCount = conditionCount;
        _this.allowCount = 0;
        _this.allowFlag = false;
        _this.conditionStatusList = {};
    };

    DelayedFunc.prototype.checkStatus = function(){
        var _this = this;

        if(_this.allowFlag){
            return true;
        }

        if(_this.allowCount == _this.conditionCount){
            _this.allowFlag = true;
            return true;
        }

        return false;
    }

    /* === Class FuncDepot begin === */
    var FuncDepot = function(){
        var _this = this;
        //初始化触发条件列表
        _this.conditionList = {};
        //初始化函数库存列表
        _this.stockList = {};
    };

    /*
    * 参数说明：
    * condition 【Array】 触发条件list
    * func 【function】 满足触发条件时，需要触发的函数
    * */
    FuncDepot.prototype.stockPush = function(condition, func){
        var _this = this,
            condition_length = condition.length,
            curStock = null,
            stockName = condition.join(‘_‘);

        if(typeof _this.stockList[stockName] == "undefined"){

            /*
             如果指定的库存函数对象不存在，就在函数库存列表中插入一个新的库存函数对象
             同时定义一个局部变量，缓存该对象（当前库存函数对象），以便后面的代码快速引用它
            */
            curStock = _this.stockList[stockName] = new DelayedFunc(func, condition_length);

        }else{

            //如果指定的库存函数对象已经存在，直接引用它
            curStock = _this.stockList[stockName];
            curStock.func = func;

        }

        if(curStock.allowFlag){

            //当前库存函数对象 的函数触发标记为true时，直接触发函数
            curStock.func.call();

        }else{

            //遍历触发条件list
            for(var i = 0; i < condition_length; i++){

                var curCondition = condition[i];
                //如果触发条件列表（conditionList）中，对应的触发条件的值为true（该条件已经被触发）
                if(_this.conditionList[curCondition]){

                    //为 当前库存函数对象 插入条件属性，并设置其值为true
                    curStock.conditionStatusList[curCondition] = true;
                    curStock.allowCount++;

                }else{

                    //否则，为 当前库存函数对象 插入条件属性，并设置其值为false
                    curStock.conditionStatusList[curCondition] = false;

                }

            }

            if(curStock.checkStatus()){

                //该函数的所有触发条件都已经触发了
                curStock.func.call();

            }

        }
    };

    /*
     * 参数说明：
     * condition 【Array】 触发条件list
     * */
    FuncDepot.prototype.stockPop = function(condition) {
        var _this = this, condition_length = condition.length, stockItem;

        //遍历函数库存列表
        for(stockItem in _this.stockList){

            for(var i = 0; i < condition_length; i++){

                var curCondition = condition[i];
                //进行库存函数名称匹配，如果库存函数名含有与某个触发条件相同的字符，说明该库存函数含有此触发条件
                if(stockItem.indexOf(curCondition) != -1){

                    var curStock = _this.stockList[stockItem];

                    if(curStock.allowFlag){

                        //如果该函数的所有触发条件都已经满足，直接触发该函数
                        curStock.func.call();
                        //并跳出名称匹配这一层循环，继续遍历函数库存列表，因为没有必要继续做条件匹配了
                        break;

                    }else{

                        //该函数并未所有触发条件满足，且当前正在触发的条件正是未被触发的
                        if(!curStock.conditionStatusList[curCondition]){

                            //将该函数的对应触发条件设为true（已触发），已触发条件数+1
                            curStock.conditionStatusList[curCondition] = true;
                            curStock.allowCount++;

                        }

                        //触发条件相关属性变更完后，判断已触发条件数是否与需要触发的条件数相同，如果相同，则所有触发条件都已触发
                        if(curStock.checkStatus()){

                            //所有触发条件都已触发，allowFlag属性设为true，并直接执行该函数
                            curStock.func.call();
                            //并跳出名称匹配这一层循环，继续遍历函数库存列表，因为没有必要继续做条件匹配了
                            break;

                        }

                    }

                }

            }

        }
    };

    /* === Class FuncDelayer begin === */
    var FuncDelayer = function(){
        var _this = this;
        _this.funcDepot = new FuncDepot();
    };

    /*
     * 参数说明：
     * condition 【String】
     * 触发条件list的表达字符串，各个条件由英文逗号","分隔开
     * 字符串中的所有空格符都会被过滤掉，建议仅用英文和数字组织触发条件名
     * func 【function】 满足触发条件时，需要触发的函数
     * */
    FuncDelayer.prototype.push = function(condition, func){
        var _this = this,
            condition = condition.replace(/ /g, ‘‘).split(‘,‘);

        for(var i = 0, j = condition.length; i < j; i++){

            var curCondition = condition[i];
            //如果该触发条件并未加入触发条件列表中
            if(!_this.funcDepot.conditionList[curCondition]){

                //将该触发条件插入到触发条件列表，触发条件的值为false（未触发）
                _this.funcDepot.conditionList[curCondition] = false;

            }

        }

        _this.funcDepot.stockPush(condition, func);
    };

    /*
     * 参数说明：
     * condition 【String】
     * 触发条件list的表达字符串，各个条件由英文逗号","分隔开
     * 字符串中的所有空格符都会被过滤掉，建议仅用英文和数字组织触发条件名
     * */
    FuncDelayer.prototype.pop = function(condition){
        var _this = this,
            condition = condition.replace(/ /g, ‘‘).split(‘,‘);

        for(var i = 0, j = condition.length; i < j; i++){

            var curCondition = condition[i];
            //如果触发条件列表中包含此触发条件，就会直接将其设为true
            //如果触发条件列表中不包含此触发条件，则会将该触发条件插入到触发条件列表，触发条件的值为true（已触发）
            _this.funcDepot.conditionList[curCondition] = true;

        }

        _this.funcDepot.stockPop(condition);
    };

    window.FuncDelayer = FuncDelayer;
})(window);

//先创建一个funDelayer对象...
var funcDelayer = new FuncDelayer();

//先来个最简单的~
$.ajax({
　　...//省略N行代码，自己补吧
　　success: function(data){
　　　　funcDelayer.pop(‘getDataSuccess‘);    
　　}    
});

funcDelayer.push(‘getDataSuccess‘, function(){
　　alert(‘成功了~~‘);
});

//先创建一个funDelayer对象...
var funcDelayer = new FuncDelayer();

//反过来也行，结果都一样~
$.ajax({
　　...//这里省略N行代码，自己补吧
　　success: function(data){
　　　　funcDelayer.push(‘getDataSuccess‘, function(){
　　　　　　alert(‘成功了~~‘);
　　　　});   
　　}    
});

funcDelayer.pop(‘getDataSuccess‘); 

//先创建一个funDelayer对象...
var funcDelayer = new FuncDelayer();

//啥？上面两个例子其实和直接执行回调函数没区别？那这样呢？
$.ajax({
　　...//省略N行代码，自己补吧
　　success: function(data){
　　　　funcDelayer.pop(‘getDataSuccessA‘);    
　　}    
});

$.ajax({
　　...//省略N行代码，自己补吧
　　success: function(data){
　　　　funcDelayer.pop(‘getDataSuccessB‘);    
　　}    
});

funcDelayer.push(‘getDataSuccessA, getDataSuccessB‘, function(){
　　alert(‘成功了~~这次可是两个异步请求都完成了才会触发哦~~‘);
});

//当然，3个甚至更多的异步请求，照样没问题

//先创建一个funDelayer对象...
var funcDelayer = new FuncDelayer();

//接下来是FunDelayer类的特性展示，下面的代码，请一句一句的，分别在控制台中执行

funcDelayer.push(‘successA‘, function(){
　　alert(‘A 成功了~~‘);
});

funcDelayer.push(‘successA, successB‘, function(){
　　alert(‘A and B 成功了~~‘);
});

//这句执行后，触发 A 函数
funcDelayer.pop(‘successA‘);

//这句执行后，触发 A 函数，因为 A 函数的触发条件在前面已经触发了，但弹出的信息变了，说明原来的函数被覆盖了
funcDelayer.push(‘successA‘, function(){
　　alert(‘A成功了，但原函数被覆盖了~~‘);
});

//这句执行后，触发 A and B 函数
funcDelayer.pop(‘successB‘);

//再一次执行这句，触发 A 函数，同时也触发 A and B 函数，如果条件 A 和 B 前面都已经触发，那么后面只要触发其中任何一个条件，都能触发 A and B 函数
funcDelayer.pop(‘successA‘);