设计模式之单例模式与策略模式

单例模式

简单就是只会执行一次的函数

//代理模式下 的 单例制造函数

var c = 1;
function letSingle () { //代理函数
  var fn = [].shift.call(arguments,1); // 获得传入的函数
  var instance; //通过闭包保存的实例,初始为undefined
  var _arguments = arguments;
  return function () { // 返回函数,形成闭包
        if(!instance) { //通过instance判断是否执行
            instance=fn.call(this,_arguments); 执行fn并且保存返回值
        }
    return instance;
  }
}

var b=letSingle(function(){
  console.info("b执行");
  return (c++);
});
//此时 b为letSingle所返回的函数;

console.info(b());
console.info(b());
console.info(b());  

输出为 : 
b执行
1
1
1

单例模式和惰性加载是非常类似的,都是通过闭包保存一个判断的变量,
不同在于,单例是判断是否返回值,每次调用,都需要判断
惰性是判断返回的函数是哪一个,只在第一次判断

策略模式

用组合,代理,多态等,将一组算法或者业务逻辑封装成一个策略类

//验证类
var validate = {
    errorMsg:[],
    strateg:{},
    addRule:function(data){
        var type;
        var name = data.name;
        // data.strateg 当data.strateg为string时,转换为数组;
        // data.name 为空则推入错误,返回this
        if(!Array.isArray(data.strateg)) data.strateg = [data.strateg];
        if(!data.name){
            this.errorMsg.push("addRule中,name不能为空"); 
            return this;
        };
        for( i in data.strateg){
            type = data.strateg[i];
            if(this.strateg[type]){
                //如果存在此规则 --- 执行验证函数
                var info = this.strateg[type](data.name,data.value,data.info);              
                if(!info) continue;
                this.errorInfo(info,data.info.errorMsg);
            }else{
                //出现不存在的验证规则,则推入一个错误
                this.errorMsg.push("不存在此验证规则:"+type);
            }
        }
        return this;                
    },
    outputError:function(){
        if(this.errorMsg.length==0) return false;   
        return this.errorMsg.join("\n");
    },
    errorInfo:function(info,customInfo){
        customInfo ? this.errorMsg.push(customInfo) : info && this.errorMsg.push(info); 
    }
}


//策略类--验证规则 
validate.strateg.isEmpty = function(name,value){
    var prompt = false;
    if(value === '' || value === undefined){
        prompt = name+"的值不能为空";
    };
    return prompt;
};
validate.strateg.isAlphaNum = function(name,value){
    var prompt = false;
    if(/[^a-z0-9]/i.test(value)){
        prompt = name+"传入的值只能是字母和数字不能包含特殊字符";
    };
    return prompt;
};
validate.strateg.isNumber = function(name,value,info){
    var prompt = false;
    var minLength = info.minLength || 6;    
    if( isNaN(value) || value.toString().length<minLength){
        var prompt = name+"只能是数字且不小于"+minLength+"位";
    };
    return prompt;
};

// 用户代码
    var data1 = "***",
        data2 = '',
        number = 123,
        string = "STRING";
        
var errors = validate
    .addRule({
        name:'data1',
        value:data1,
        strateg:["isEmpty","isAlphaNum"],
        info:{
            
        }   
    })
    .addRule({
        name:'number',
        value:number,
        strateg:["isEmpty","isNumber"],
        info:{
            minLength:6
        }   
    })
    .addRule({
        name:'string',
        value:string,
        strateg:["isEmpty","isArr","isNumber"],
        info:{
            minLength:9
        }   
    })
    .addRule({
        name:'data2',
        value:data2,
        strateg:"isEmpty",
        info:{
            minLength:6
        }   
    })
    .addRule({
        value:string,
        strateg:"isEmpty",
        info:{
            minLength:6
        }   
    })
    .outputError();
    console.error(errors);

    输出为
data1传入的值只能是字母和数字不能包含特殊字符
number只能是数字且不小于6位
不存在此验证规则:isArr
string只能是数字且不小于9位
data2的值不能为空
addRule中,name不能为空

总体就是将验证规则组成一个策略组,然后validate对象将验证交给这个组代理

转载于:https://www.cnblogs.com/LiangHuang/p/6413913.html