一、6种设计模式
构造函数constructor模式
构造函数模式是创建特定类型的对象的一种模式，把私有属性绑定到函数内部的this上，把一些私有方法写到函数的原型链上, 然后通过new 关键字来创建一个实例对象。每个实例都会有自己的一份实例属性，但同时又共享着方法，最大限度的节省了内存。
//1.构造函数模式
function Person(name,age){
this.name = name;
this.age = age;
}//方法都写在原型链上面
Person.prototype.sayName = function(){
return this.name;
}
var student = new Person('yuhuan',24)//每次new创建一个新的引用
工厂模式factory
需要一个对象的时候可以通过这个函数创建一个对象，
但是这个对象没有构造函数，无法用 instanceof 的方法判断是否为实例。
//2.工厂模式factory
//对象是引用类型，存储在堆内存中，工厂模式的关键点是每次创建一个新的引用
function createPerson(name){
var person={
name: name,
sayName: function(){console.log(this.name)}
}
return person;
}
createPerson('yuhuan')
createPerson('yuhuan').sayName() //createPerson('yuhuan') return出来一个对象person，方法调用，this指向调用方person
var t = createPerson('yuhuan').sayName;
t()//函数调用模式，t是函数，this指向window
因为不实现继承，创建100次，就会有100个sayName方法
单例模式
保证一个类仅有一个实例，并提供一个获得该实例的方法。
js中，每个对象字面量都可以看做是一个单例。
var singleton = {
attr : 1,
method : function(){ return this.attr; }
}
var t1 = singleton ;
var t2 = singleton ;
t1 === t2 //true
t1.method() //1
单例模式的思路是：一个类能返回一个对象的引用（并且永远是同一个）和一个获得该实例的方法（静态方法，通常使用 getInstance 名称）。那么当我们调用这个方法时，如果类持有的引用不为空就返回该引用，否者就创建该类的实例，并且将实例引用赋值给该类保持的那个引用再返回。同时将该类的构造函数定义为私有方法，避免其他函数使用该构造函数来实例化对象，只通过该类的静态方法才能得到该类的唯一实例。
实现单例核心思想
使用数据缓存来存储该单例，用作判断单例是否已经生成，是单例模式主要的实现思路。以下使用闭包方式来模拟私有数据。var instance相当于People内部的一个变量，不能被外界看到，这就是闭包的作用，模块化，隐藏变量。
//3.单例模式singleton,常用来写对话框dialog,每次弹出来的对话框就是同一个
var People = (function(){
var instance;
function createPerson(name){
if(!instance){
instance = new Init(name)
}
return instance;
}
function Init(name){
this.name = name;
}
return {
createPerson: createPerson
}
})()
var p1 = People.createPerson('yuhuan')
var p2 = People.createPerson('tang')
p1===p2 //true
混合模式mixing
建立在构造函数模式的基础上，实现子类继承父类的属性和方法，子类可以在扩展属性和方法。
//4.混合模式mixing
function inherit(superType, subType){
subType.prototype = Object.create(superType.prototype);
subType.prototype.constructor = subType;
}
#使用方法
function Person(name, sex){
this.name = name;
this.sex = sex;
}
Person.prototype.printName = function(){
console.log(this.name);
};
function Male(name, sex, age){
Person.call(this, name, sex);
this.age = age;
}
inherit(Person, Male);
// 在继承函数之后写自己的方法，否则会被覆盖
Male.prototype.printAge = function(){
console.log(this.age);
};
var m = new Male('Byron', 'm', 26);
m.printName();
模块模式module
闭包来实现
使用立即执行函数包裹代码段，使内部的私有变量和方法不会暴露出来，通过return函数给外部提供使用内部方法的接口。
这样的好处是不会污染全局变量，外部无法访问或者改变模块内部的变量和方法。
//5.模块模式module 一个模块往往代表了一个封闭的作用域
var Person = (function(){
var name = 'yuhuan'
function sayName(){
console.log(name)
};//词法作用域
return{
name:name,
sayName: sayName
}
})()
使用：
Person.sayName();// yuhuan
Person.name;//yuhuan
发布订阅模式（观察者模式）publish/subscribe
观察者模式又叫发布订阅模式（Publish/Subscribe），一个订阅者对象订阅发布者对象的特定活动，并在发布者对象的状态发生改变后，订阅者对象获得通知。订阅者也称为观察者，而被观察的对象称为发布者或主题。
当发生了一个重要的事件时，发布者将会通知（调用）所有订阅者，并且可能经常以事件对象的形式传递消息。（浏览器的事件也是观察者模式）
使用观察者模式，可以自定义发布事件，事件处理函数，通过订阅事件来触发事件，执行函数。
/*6.发布订阅模式publish/subscribe
浏览器控制台运行演示：
EventCenter.on('hello',function(){ //发布'hello'
console.log('hi')
})
EventCenter.fire('hello')//订阅'hello'，得到输出结果hi
*/
var EventCenter = (function(){
var events = {};//用来存储所有的key/value
//('hello',function(){})
function on(evt,handler){
//events['hello'] = []
//然后 events['hello'] = [{
// handler: 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(name){
delete events[name]
}
//暴露出的api
return {
on: on,
fire: fire,
off: off//取消订阅
}
})();
二、使用发布订阅模式写一个事件管理器，实现如下方式调用
EventCenter.on('change', function(val){
console.log('change... now val is ' + val);
});
EventCenter.fire('change', '饥人谷');
EventCenter.off('change');
#发布订阅模式
var EventCenter = (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(name){
delete events[name]
}
//暴露出的api
return {
on: on,
fire: fire,
off: off//取消订阅
}
})();
