js设计模式

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

1、设计模式分类：

构造函数模式（constructor）

含义：创建一个构造函数

function Person(name,age){
  this.name=name;
  this.age=age;
}
Person.prototype.sayName=function(){
   return this.name;
}
var student=new Person("Ethan",28);

工厂模式（factory）

含义：通常是一个函数return出来一个新的对象

function createPerson(name){
  var person={
    name: name,
    sayName:function(){
       return this.name;
     }
  }
  return person;
}
createPerson("Ethan");
this回顾：
1、方法调用模式：createPerson("Ethan").sayName(); this指向person
2、函数调用模式： var t=createPerson("Ethan").sayName;   this指向window
3、new构造对象：this指向新构造的对象
4、自动指向：apply,call,bind方法

单例模式（singleton）

含义：每次调用这个模式不会去创造，有且只有一个（例子：组件生成的对话框，一个页面只出现一次）

var People=(function(){
  var instance;
  function init(name){
    return {
       name: name
    }
  }
  return {
    createPeople:function(name){
       if(!instance){
         instance=init(name);
       }
       return instance;
    }
  }
})();
//函数作用域：词法作用域，js作用域由function所体现，function访问的上下文由它所在定义的位置所决定
People.createPeople("Ethan");
People.createPeople("age");

混合模式（mixin）

含义：对某个对象，增加新的东西（一般都用来混合它的原型）

function People(name,age){
  this.name=name;
  this.age=age;
}
People.prototype.sayName=function(){
  console.log(this.name);
}
var Student=function(name,age,score){
  People.call(this,name,age);
  this.score=score;
}
//用原生js方法将student.prototype指向People
Student.prototype=create(People.prototype);

function create(parentObj){
  function F(){}
  F.prototype=parentObj;
  return new F;
}
Student.prototype.sayScore=function(){
  console.log(this.score);
}
var student=new Student("Ethan","28","97")

模块模式（module）

含义：一般通过闭包的方式实现的，特点：避免全局变量的冲突

var Person=(function(){
  var name="Ethan";
  function sayName(){
    console.log(name);
  }
  return: {
    name: name,
    sayName:sayName
  }
})();

策略模式

含义：根据不同参数命中不同的策略, 特点：避免if…else判断

const strategy = {
  'S': function(salary) {
    return salary * 4
  },
  'A': function(salary) {
    return salary * 3
  },
  'B': function(salary) {
    return salary * 2
  }
}

const calculateBonus = function(level, salary) {
  return strategy[level](salary)
}

calculateBonus('A', 10000) // 30000

代理模式

// 图片加载：传统方案
var realImg='http://new-img2.ol-img.com/985x695/79/172/lic9i4TykRiA.jpg';  //真实图片
var xiaojuhua='http://www.wallpaperama.com/post-images/forums/200903/07p-6606-loadingcircle.gif'; //小菊花图片

function loadImg(loaddingImg,realImg){
  var imgNode = document.createElement('img');  
  document.body.appendChild(imgNode);  
   
  imgNode.src = loaddingImg;
   
  var proxyImg = new Image();
  proxyImg.src = realImg;
   
  proxyImg.onload = function(){
    imgNode.src=this.src;
  }
}
loadImg(xiaojuhua,realImg)
// 问题：耦合性太高，loadImg函数违背了面向对象设计原则中的单一职责原则，同时完成了创建img，设置loading加载状态等多个任务。

// 代理模式方案
var xiaojuhua='http://www.wallpaperama.com/post-images/forums/200903/07p-6606-loadingcircle.gif';
var realImg= 'http://new-img2.ol-img.com/985x695/79/172/lic9i4TykRiA.jpg';
 
 //这个方法只负责创建img标签，对外暴露设置img的src接口
function myImage(){
 var image=document.createElement('img');
  document.body.append(image);
  return {
    set:function(src){
      image.src=src;
    }
  }
}
//在body里面异步加载图片，传入图片地址参数，和本地loadding图片
// 其中的加载loading图片交给代理函数ProxyImage 去做，当图片加载成功后，代理函数ProxyImage 会通知及执行myImage 函数的方法，同时当以后不需要代理对象的话，我们直接可以调用本体对象的方法即可。
var myImg=myImage();
var proxyImage=function(){
  var img=new Image();
  img.onload=function(){
    console.log(this);
    myImg.set(this.src);
  }
  return {
    set:function(loadimg,src){
        img.src=src;
        myImg.set(loadimg);
    }
  }
}
 
var proxy=proxyImage();
proxy.set(xiaojuhua,realImg);

订阅发布模式（subcribe/publish）

含义：先订阅后发布，相当于事件监控模式，先定义好函数，再在任何时候异步同步触发事件

var EventCenter=(function(){
  var events={};    //存储所有的key/value
  //events={"hello":[{function(){}:function(){}},{function(){}:function(){}},...]}
  function on(evt,handle){
    events[evt]=events[evt] || [];
    events[evt].push({
      handle:handle
    });
    //events["hello"]=[{handle:handle}]
  }
  function fire(evt,args){
    if(!events[evt]) return;
    for(var i=0;i<events[evt].length;i++){
      events[evt][i].handle(args);
    }
  }
function off(name){
    delete events[name];
  }
  return {
    on:on,
    fire:fire,
    off:off
  };
})();

EventCenter.on("hello",function(word){
  console.log(word);
});
EventCenter.fire("hello","word");

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

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

var Event=(function(){
  var events={};    //存储所有的key/value
  //events={"hello":[{function(){}:function(){}},{function(){}:function(){}},...]}
  function on(evt,handle){
    events[evt]=events[evt] || [];
    events[evt].push({
      handle:handle
    });
    //events["hello"]=[{handle:handle}]
  }
  function fire(evt,args){
    if(!events[evt]) return;
    for(var i=0;i<events[evt].length;i++){
      events[evt][i].handle(args);
    }
  }
function off(name){
    delete events[name];
  }
  return {
    on:on,
    fire:fire,
    off:off
  };
})();

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