常见的设计模式

记录一下我对JavaScript中常见的设计模式的理解。
设计模式就是对特定类型问题重用的软件解决方案，这些问题在软件开发的时候经常会碰到，通过很多年的实践，专家对一些相似地问题总结出一些方法，这些方法就封装成为一种设计模式

1. 构造函数模式

这个模式还是比较好理解的，写一个构造函数，通过 new 调用，写个简单的构造函数的例子，如下：

function Person(name){
    this.name = name;
}
Person.prototype.sayName = function(){
    return this.name;
}
var someone = new Person('Mike')
console.log(someone)  // Person {name: "Mike"}
someone.sayName() // Mike

2. 工厂模式

工厂模式就是一个函数，return 出来已给对象，工厂模式的好处在于创建一个新的引用，我们知道，对象在存储中其实是一个引用类型，工厂模式和构造函数模式都是为了避免指向同一个引用，写个简单的工厂模式的例子，如下：

function createPerson(feature){
    var person = {
        name: feature.name || 'anonymous'
    };
    person.sayName=function(){
       console.log(this.name)
    }
    return person
}
var p1 = createPerson({name:'Mike'});
var p2 = createPerson({name:'Will'});
p1.sayName() // Mike
p2.sayName() // Will

3. 单例模式

单例模式通常在闭包中存储一个单例，使用单例模式的好处在于，节约内存，执行的时候并不会创造一个新的对象，而是给出指向

var People = (function(){
    var instance;
    function init(){
        var name = 'Mike'
        function sayName(){
            console.log(name)
        }
        return{
            name:name,
            sayName:sayName
        }
    }
    return{
        createPeople: function(){
            if(!instance){
               console.log('实例第一次创建')
               instance = init()
            }
            else{console.log('实例已创建')}
            return instance;
        }
    }
})()

var obj1 = People.createPeople(); // 实例第一次创建
var obj2 = People.createPeople(); // 实例已创建
obj1.sayName(); // Mike
obj2.sayName(); // Mike

4. 模块模式

模块模式通过闭包来实现一个模块

var Person = (function(){
    var name = 'Mike'
    function sayName(){
        console.log(name)
    }
    return {
        name: name,
        sayName:sayName
    }
})()
Person.sayName() // Mike

5. 混合模式

混合模式一般而言是混合它的原型，key/value

var Person = function (name) {
    this.name = name;
}
Person.prototype.sayName = function () {
    console.log(this.name);
}
var Someone = function (name, age) {
    Person.call(this, name);
    this.age = age;
}

function extend(Child,Parent) {
    var F = function () { };
    F.prototype = Parent.prototype;
    Child.prototype = new F();
    Child.prototype.constructor = Child; 
}
extend(Someone,Person)
Someone.prototype.sayAge = function(){
    console.log(this.age)
}
var someone = new Someone('Mike',19)
console.log(someone) // Someone { name: 'Mike', age: 19 }
someone.sayName() // Mike
someone.sayAge() // 19

6. 发布订阅模式

发布订阅模式是一个很值得一提的模式，它可以让你的代码解耦

var Event = (function () {
    var events = {};    //存储所有的key/value
    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) {
        if (events[evt]) {
            delete events[evt];
        }
        return;
    }
    return {
        on: on,
        fire: fire,
        off: off    //取消订阅
    }
})()
Event.on('change', function (val) {
    console.log('change...  now val is ' + val);
});
Event.fire('change', '饥人谷'); // change...  now val is 饥人谷
Event.fire('change', '饥人谷again');  // change...  now val is 饥人谷again
Event.off('change');
Event.fire('change', 'nochange'); //无输出