*工廠模式factory

DEMO                                         使用場景：創建一個簡單的對象
   function Person(name) {                  
     var temp={                           
       temp.name=name;
       temp.sayName=function () {
         console.log(this.name);
       }
     };
     return temp;
   }
   createPerson("Lucy");                     生成實例 = 創建一個新的引用方式
   createPerson("Eall");                                 開辟新的內存空間

   與構造函數同為 引用類型 ； 但無法知道實例是由哪個構造函數創建的

*構造函數模式constructor

DEMO                                          使用場景：創建一個復雜的對象，可以添加方法
   function People(name,age){                  
       this.name = name;                      寫一個函數
       this.age = age;                         綁定this
   }
   People.prototype.sayName = function(){      將方法掛在函數原型上
        console.log(this.name)
   }
   var singer = new People('Jay','33');        使用new生成實例 開辟內存空間
   singer.sayName();

*單例模式single

DEMO                                 使用場景：只需出現一次，獨一無二的組件
    var Person=(function () {                 一個立即執行函數
      var temp;
      function init(name,age) {                
        return {
            name:name,
            age:age,
            sayName:function () {
                console.log(this.name);       return出來的值是 閉包里的變量
             }
          }
       }
       return {
          createPerson:function (name,age) {
            if(!temp){                        // 如果沒有temp就初始化
                temp=init(name,age);       
            }                             // 所以第一次調用就初始化，之后不再執行這段代碼
            return temp;                      
          }                                  單例就是只開辟了一個內存空間
       }                                     第一次傳入的值被儲存下來
    }());                                    之后生成的實例全都指向同樣的地方 
    Person.createPerson("lucy",23); // lucy
    Person.createPerson("lily",24);// lucy

*混合模式mixin

DEMO                                            使用場景：可繼承的公用方法
   function Person(name,age) {                           構造函數 1
       this.name=name;
       this.age=age;
   }
   Person.prototype.sayName=function () {                 
       console.log(this.name);
   }

   function Student(name,age,score) {                    構造函數 2
       Person.call(this,name,age);
       this.score=score;
   } 
   Student.prototype.sayScore=function () {     
       console.log(this.score);
   }

inherit 1：
   function inherit(parent,sun) {                        
       sun.prototype=Object.create(parent.prototype);    差異化繼承
       sun.prototype.constructor=sun;
   }
   inherit(Person,Student);                              2就繼承了 1
inherit 2：
   student.prototype=create(parent.prototype); 
   function creat(parentObj){
       function F(){}//新建一個空對象
       F.prototype=parentObj;//原型指向參數
       return new F;//實例化一個原型指向參數的空對象
   }

   var student1=new Student("lucy",24,100);
   student1.sayScore();
   student1.sayName();

*模塊模式moudle

DEMO                                       使用場景：需要封裝的組件
   var person=(function () {
        var name="lucy",            一個模塊 = 一個私有作用域 = 一個匿名函數
        age=23;
      function sayName() {
        console.log(name);
      }// 詞法作用域：一個函數可以訪問到的上下文環境由它所定義的位置決定。
      return{                                     
        name:name,                      留出接口
        age:age,
        sayName:sayName
      }
   })();
   person.sayName();

*發布訂閱模式subscribe publish

DEMO
    var EventCenter=(function () {  // 新建訂閱中心

      var events={};                // 新建緩存列表，存儲訂閱者的回調函數

      function on(evt,handler) {    // 添加消息：綁定事件
        events[evt]=events[evt]||[];// 檢查事件列表events{}里是否有這個key 
                                       *如果有，那就是這個事件了；
                                       *如果沒有，就初始化這個數組，加入事件
        events[evt].push({          // 在[]里增加一個函數
            handler:handler         // 即 events={evt:[handler:handler]}
        })                               events={事件：[訂閱者1：function(args){...}; 
       }                                               訂閱者2：function(args){...};
                                                                                  ] }
      function off(evt) {           // 解除訂閱：移除事件
        delete events[evt];
      }
      function fire(evt,args) {     // 發布訂閱：觸發事件
        if(!events[evt]){           // 如果evt不存在，就返回
            return;
        }                           // 如果存在，遍歷列表events，依次執行處理程序
        for(var i=0;i<events[evt].length;i++){
            events[evt][i].handler(args);
        }
      }
      return {
        on:on,                       // 導出接口
        off:off,
        fire:fire
      }
    })();
    EventCenter.on('change', function(val){
      console.log('change...  now val is ' + val);
    });
    EventCenter.fire('change', '饑人谷'); //change...  now val is 饑人谷
    EventCenter.off('change');

    優點：代碼解耦；異步使用；實現自定義組件