js设计模式总结3

var Observer=(function(){
        //防止消息队列爆满而被篡改故将消息容器作为静态私有变量保存
        var _messages={};
        return {
            注册信息接口,是将订阅者注册的消息推入到消息对列中
            regist:(type,fn){
                if(typeof _messages[type]==='undefined'){
                    _messages[type]=[fn];
                }else{
                    将动作方法推入该消息对应的动作执行序列中
                    _messages[type].push(fn);
                }
            },发布消息接口
            fire:如果消息没有被注册，则返回
                if(!_messages[type])
                ;
                var events={
                    type:type,args:args||{}
                },i=0,len=_messages[type].length;
                for(;i<len;i++){
                    依次执行注册的消息对应动作序列
                    _messages[type][i].call(this移除消息接口
            remove:if(_messages[type] instanceof Array){
                    var i=_messages[type].length-1;
                    for(;i>=0;i--){
                        如果存在该动作，则移除该动作
                        _messages[type][i]===fn && _messages[type].splice(i,1);
                    }
                }
            }
        }
    })();

        var Result=(){
            判断结果保存在内部状态中
            var States={
                每种状态作为一种独立的方法保存
                state0:(){},state1:(){}
            }
            获取某一种状态并执行其对应的方法
             show(result){
                States["state"+result]  && States["state"+result]();
            }
             {
                返回调用转态方法接口
                show:show
            }
            
        }();        

var MarryState=每种状态作为一种独立的方法保存
                move:(){}
            }
        };
            
        var Action={
            changeState:(){
                组合通过传递多个参数进行实现
                var arg=arguments;
                重置内部状态
                _currentState={};
                如果有动作则添加动作
                if(arg.length){
                    遍历动作
                    for(var i=0,len=arg.length;i<len;i++向内部状态中添加动作
                        _currentState[arg[i]]=true;
                    }
                }
                方便链式调用
                return ;
            },goes:遍历内部保存的动作
                var i in _currentState){
                    动作存在则执行
                    States[i]&&States[i]();
                }
                ;
            }
                        change:Action.change,goes:Action.goes
            }
        };
    创建一个实例
    var marry=new MarryState();
    marry
        .change("jump","shoot")
        .goes()
        .goes()
        .change("shoot")
        .goes();

            var PriceState=内部算法对象
            {
                return30:(price){},return50:(price){}
            }
            策略算法调用接口
            (algorithm,price){
                如果算法存在，则调用算法
                return States[algorithm]&&States[algorithm](price)
            }
        };

var InputState={
                notNull:(value){},number: {
                check:);
                    return States[type]&&States[type](value);
                },addState:fn;
                }
            }
        };