前端设计模式

1.写出 构造函数模式、混合模式、模块模式、工厂模式、单例模式、发布订阅模式的范例。

构造函数胡模式(constructor)

构造函数用于创建特定类型的对象-不仅声明了使用的对象，还可以接收参数以便第一次创建对象的时候设置对象的成员值。通过new关键字来调用自定义的构造函数，在构造函数内部，this关键字引用的是新创建的对象。

function Person(name,age){
    this.name = name
    this.age = age
}
Person.prototype = {
    sayName:function(){
        return this.name
    },
    showAge:function(){
        return this.age
    }
}
var student = new Person('小明',15)
student.sayName()
student.showAge()

工厂模式(factory)

解决多个类似对象声明的问题;也就是为了解决实列化对象产生重复的问题。

function createPerson(name){
    var person = {
        name: name,
        sayName:function(){
            console.log(this.name) 
        }
    }
    return person
}
createPerson('小明').sayName()

模块模式(module)

模块模式使用了一个返回对象的匿名函数。在这个匿名函数内部，先定义了私有变量和函数，供内部函数使用，然后将一个对象字面量作为函数的值返回，返回的对象字面量中只包含可以公开的属性和方法。这样的话，可以提供外部使用该方法；由于该返回对象中的公有方法是在匿名函数内部定义的，因此它可以访问内部的私有变量和函数。

var Person = (function(){
    var name = 'xiaoming'
    function sayName(){
        console.log(name)
    }

    return {
        name:name,
        sayName:sayName
    }
})()

混合模式(mixin)

实现原型继承，通过一个构造函数来定义属性，把共享的方法定义在原型链上，减少系统中的重复功能及增加函数复用

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

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

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


var _prototype  = Object.create(Person.prototype);
// _prototype.constructor = Male; 
Male.prototype  = _prototype;

Male.prototype.getAge = function(){
    console.log(this.age)
};

var student = new Male('小明', '男', 15);
student.getName();

单例模式(singleton)

保证一个类只有一个实例，实现的方法一般是先判断实例存在与否，如果存在则直接返回，如果不存在就创建了再返回，这就确保了一个类只有一个实例对象。在JavaScript中，单例作为一个命名空间提供者，从全局命名空间里提供一个唯一的访问点来访问该对象。
js的作用域体现在函数中，外界不能访问到函数内部的变量；
函数能访问的上下文作用域是它定义的位置所决定；
闭包：隐藏函数内部的变量，存储一个变量

var Person =(function(){
    var instance
    function init(name){
        return {
            name:name
        };
    }

    return {
        createPerson: function(name){
            if(!instance){
                instance = init(name)
            }
            return instance
        }
    }
})();

Person.createPerson('student') //{name:student}
Person.createPerson('teacher') //{name:student} 把原来的引用给拿出来

发布订阅模式(pubish/subsciibe)

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知。对外导出的Api是on,fire,off

var EventCenter = (function(){
    var  events = {}; //存储所有数据
    function on(evt,handler){
        //一开始events[evt] = []空数组
        events[evt] = events[evt] || [];
        //把handler添加到数组，handler为函数
        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(name){
        delete events[name]
    }

    return {
        on:on,
        fire:fire,
        off:off
    }   
})()

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('change');