设计模式

构造函数模式

 function Person(name,age,sex){
        this.name=name;
        this.age=age;
        this.sex=sex;
    }
    Person.prototype.eat=function(){
        console.log("吃东西");
    }
    var p1=new  Person("小明",18,"男");

混合模式

混合模式就是构造函数模式和原型模式的混合，在混合模式中，构造函数用于定义实例属性，而原型模式用于定义方法和共享的属性。

    function Person(name, age){
        this.name=name;
        this.age=age;
    }

    Person.prototype.getName = function(){
        console.log(this.name)
    };

    Person.prototype.getAge = function(){
        console.log(this.age);
    };
    var p1=new Person("小明",19,"男");
   p1.getAge();//19

模块模式

模块模式能够使一个单独的对象拥有公有/私有方法和变量,从而屏蔽来自全局作用域的特殊部分

var Goods=(function(){
          //声明私有成员
           var price=100;
          function getPrice(){
                 console.log(price);
            }
         // 暴露公开的成员
         return{
             getPrice:getPrice
         }
    })()
    var p=Goods.getPrice();
    console.log(p)//100

工厂模式

工厂模式抽象了具体对象的过程，函数可以接受传来的参数构建一个包含所有必要信息的对象，可以无数次的调用这个函数，每次都返回一个包含属性和方法的对像的引用。

  function createPerson(name,age,sex){
        var person={
            name:name,
            age:age,
            sex:sex,
             sayName:function(){
                 console.log(this.name)
             }
        }
        return person;
    }
    var p1=createPerson("小明",28,"男");

单例模式

单例模式就是保证一个类只有一个实例，实现的方法一般是先判断实例存在与否，如果存在直接返回，如果不存在就创建了再返回，这就确保了一个类只有一个实例对象。

1.
var mySingleton = function () {
        /* 这里声明私有变量和方法 */
        var privateV = 'private';
        function showPrivate() {
            console.log(privateV);
        }

        /* 公有变量和方法（可以访问私有变量和方法） */
        return {
            publicMethod: function () {
                showPrivate();
            }；
        };
    };

    var single = mySingleton();
    single.publicMethod();  // 输出  private

2.
var Singleton = (function () {
    var instantiated;
    function init() {
        return {
            publicMethod: function () {
                console.log('hello world');
            },
            publicProperty: 'test'
        };
    }
    return {
        getInstance: function () {
            if (!instantiated) {
                instantiated = init();
            }
            return instantiated;
        }
    };
})();

发布订阅模式

在发布订阅者模式中订阅者事件的触发是订阅者通过监听一个特定的消息(这个消息一般包含名称和订阅者所需要的参数)来触发的。可以理解为订阅者监听的不是发布者，而是消息池，只要消息池里有它关心的消息，即触发事件，不管这个消息是谁发布过去的。发布者和订阅者是解耦的。

var PubSub = function(){
      this.eventPool = {}; 
    };
    PubSub.prototype.off = function(topicName){
        delete this.eventPool[topicName]
    };
    PubSub.prototype.on = function(topicName,callback){
        var  topic = this.eventPool[topicName] ; 
        if(!topic){
            this.eventPool[topicName] =[] 
        }
        this.eventPool[topicName].push(callback)
    }
    PubSub.prototype.trigger = function(){
        var _arg = [].slice.call(arguments);
        var topicName=_arg.shift();
        var callbackArg = _arg;
        var topicCallback = this.eventPool[topicName]
        if(topicCallback){
             topicCallback.forEach(function(callback){
                callback.apply(this,callbackArg)
             });
        }
    };

2.使用发布订阅模式写一个事件管理器，可以实现如下方式调用

 var Event = (function(){
        var events = {}

        function on(evt, handler){
            events[evt] = events[evt] || [];
            events[evt].push({
                handler: handler
            })
        }
        function fire(evt, args){
            if(!events[evt]){
                return
            }
            for(var i=0; i<events[evt].length; i++){
                events[evt][i].handler(args)
            }
        }
        function off(evt){
            delete events[evt]
        }
        return {
            on: on,
            fire: fire,
            off: off
        }
    })();


Event.on('change', function(val){
    console.log('change...  now val is ' + val);  
});
Event.fire('change', '饥人谷');
Event.off('changer');