JS-设计模式

JS工厂模式

工厂模式是将创建对象的逻辑封装在一个函数内，不必暴露创建对象的逻辑，那么这个函数就可以称之为工厂

	 let factory = function (rule) {
            function manager() {
                this.name = "管理员";
                this.work = "管理人员";
            }
            function employee() {
                this.name = "员工";
                this.work = "被管理人员";
            }
            switch (rule) {
                case 'manager':
                    return new manager();
                    break;
                case 'employee':
                    return new employee();
                    break;
                default:
                    throw new Error("参数错误");
            }
        };

        let manager = new factory("manager");
        let employee = new factory("employee");

factory就是一个简单工厂，在创建对象时，传入约束值，从而创建不同对象。
优点：只需要传入一个合法的值，就可以得到你想要的对象以及方法，而无需考虑过程，直接得到；
缺点：工厂类集中了所有的的创建逻辑，一旦失效影响整个代码区域

JS单例模式

单例模式在全局中只声明一个命名空间，他生成一个唯一的的全局变量。单例模式限制了类的实例化次数只能是一次。

	function getSingleton(fn) {
        //初始化一个实例
        let instance = null;
        return function () {
        //如果实例存在返回实例 不存在则创建
            if (!instance){
            	//传进来的fn是一个回调函数 返回一个对象
                //这里使用了参数列表arguments
                //apply 使用当前值替换函数原有的形参
                instance = fn.apply(this,arguments);
            }
            console.log(instance);
            return instance;
        }
    }

	//创建两个对象
    let setManager = function(name){
        this.manager = name;
    };

    let setHr = function(name){
        this.hr = name;
    };

	//分别给这两个对象添加原型方法
    setManager.prototype.getName = function(){
        return this.manager;
    };

    setHr.prototype.getName = function(){
        return this.hr;
    };

    let managerSingleton = getSingleton(function (name) {
        let manager = new setManager(name);
        return manager;
    });
    let hrSingleton = getSingleton(function (name) {
        let hr = new setHr(name);
        return hr;
    });

    console.log(managerSingleton("Lucy").getName());
    console.log(hrSingleton("Linda").getName());

策略模式

策略模式指的是定义一系列的算法，把它们一个个封装起来。一个基于策略模式的程序至少由两部分组成。第一个部分是一组策略类，策略类封装了具体 的算法，并负责具体的计算过程。 第二个部分是环境类Context，Context 接受客户的请求，随后 把请求委托给某一个策略类。

	//策略
    //错误提示
    var errorMessage = {
        default: '输入数据格式不正确',
        minLength: '输入数据长度不足',
        isNumber: '请输入数字',
        required: '内容不为空',
        maxLength: '输入数据长度太长'
    };

    // 规则集   策略集
    var rules = {
        minLength: function (value, length, errorMsg) {
            if (value.length < length) {
                return errorMsg || errorMsgs['minLength']
            }
        },
        maxLength: function (value, length, errorMsg) {
            if (value.length > length) {
                return errorMsg || errorMsgs['maxLength']
            }
        },
        isNumber: function (value, errorMsg) {
            if (!/\d+/.test(value)) {
                return errorMsg || errorMsgs['isNumber'];
            }
        },
        required: function (value, errorMsg) {
            if (value === '') {
                return errorMsg || errorMsgs['required'];
            }
        }
    };

    //校验器
    function Validator() {
        this.items = [];
    }

    Validator.prototype = {
        constructor : Validator,
        add : function (value, rule, errmsg) {
            var arg = [value];
            if (rule.indexOf(":")!=-1){
                var arr = rule.split(":");
                arg.push(arr[1]);
                rule = arr[0];
            }
            arg.push(errmsg);

            //将分割好的参数传入验证方法
            this.items.push(function () {
                return rules[rule].apply(this,arg);
            });
        },

        start : function () {
            for (var i=0;i<this.items.length;i++){
                var info = this.items[i]();
                if (info){
                    console.log(info);
                }
            }
        }
    };

    var validator = new Validator();
    validator.add("12345","minLength:6","输入数据长度不足");
    validator.add("abc","isNumber","请输入数字");
    validator.start();