JsDesignMode第二篇

創建型設計模式
    處理對象創建的設計模式,控制對象的創建來避免基本對象創建時
    可能導致設計上的問題或增加設計上的複雜度
1.簡單工廠模式
       1.1也稱爲靜態工廠方法
             由一個工廠對象決定創建某一種產品對象類的實例,創建同一類對象
       1.2類太多,提供一個
            

 //封裝在一個函數中,只需要記住這個函數,不需要知道基類
 //這個函數被稱爲工廠函數,這個模式叫簡單工廠模式
        var LoginAlert = function(text){
            this.content = text;
        }
        LoginAlert.prototype.show = function(){
            //顯示警示框
        }
        var LoginConfirm = function(text){
            this.content = text;
        }
        LoginConfirm.prototype.show = function(){
            //顯示確認框
        }
        var LoginPrompt = function(text){
            this.content = text;
        }
        LoginPrompt.prototype.show = function(){
            //顯示提示框
        }
        工廠:
        var PopFactory = function(name){
            switch(name){
                case 'alert':
                    return new LoginAlert();
                case 'confirm':
                    return new LoginConfirm();
                case 'prompt':
                    return new LoginPrompt();
            }
        }

       1.3.上面是對不同的類進行實例化,簡單工廠模式的理念是創建對象
                     提取相似的東西,不相似的針對性處理
     

   function createPop(type, text){
            var o = new Object();
            o.content = text;
            o.show = function(){
                //顯示方法
            }；
            if(type == 'alert'){
                //警示框
            }
            if(type == 'confirm'){
                //確認框
            }
            if(type == 'prompt'){
                //提示框
            }
        }

     1.4區別
                 第一種是通過類實例化來創建
                       繼承同一父類,父類原型上的方法是可以共用的
                第二種是創建一個新對象然後包裝增強其屬性和功能來實現
                      創建了一個新個體,方法也就不能共用了
2.工廠方法模式
        2.1對產品類的抽象使其創建業務主要負責用於創建多類產品的實例
             只需要添加一個類
             看作一個實例化對象的工廠類,將創建對象的基類放在工廠方法類的原型當中
             安全模式:避免錯誤,比如未使用new
      

  var Factory = function(type, content){
            if(this instanceof Factory){
                var s = new this[type](content);
                return s;
            }else{
                return new Factory(type, content);
            }
        }
        Factory.prototype = {
            Java : function(content){
                //...
            },
            JavaScript : function(content){
                //...
            }
        }; 

 
3.抽象工廠模式
         對類的工廠抽象使其業務用於對產品類族的創建
4.建造者模式
         將一個複雜對象的構建層與其表示層相互分離,同樣的構建過程可採用不同的表示
         關心於創建這個對象的整個過程,甚至每一個細節
       

var Human = function(param){
            this.skill = param && param.skill || '保密'；
            this.hobby = param && param.hobby || '保密'；
        }
        Human.prototype = {
            getSkill : function(){
                return this.skill;
            },
            getHobby : function(){
                return this.hobby;
            }
        }
        var Named = function(name){
            var that = this;
            (function(name, that){
                that.wholeName = name;
                if(name.indexOf('') > -1){
                    that.FirstName = name.slice(0, name.indexOf(''));
                    that.SecondName = name.slice(name.indexOf(''));
                }
            })(name, that);
        }
        var Work = function(work){
            var that = this;
            (function(work, that){
                switch(work){
                    case 'code':
                        that.work = '工程師'；
                        that.workDescript = '每天編程'；
                        break;
                    case 'UI':
                    case 'UE':
                        that.work = '設計師'；
                        that.workDescript = '設計更似一種藝術'；
                        break;
                    default:
                        that.work = work；
                        that.workDescript = 'NOT FOUND'；
                }
            })(work, that);
        }
        Work.prototype.changeWork = function(work){
            this.work = work;
        }
        Work.prototype.changeDescript = function(setence){
            this.workDescript = sentence;
        }
        //建造者類
        var Person = function(name, work){
            var _person = new Human();
            _person.name = new Named(name);
            _person.work = new Work(work);
            return _person;
        }

5.原型模式
        用原型實例指向創建對象的類,使用於創建新的對象的類共享原型對象的屬性和方法
        將可複用、可共享、耗時大的從基類中提出來然後放在原型之中
        然後子類將方法和屬性繼承下來,對於那些需要重寫的方法進行重寫
        既有了自己的屬性和方法又有了原型的屬性和方法
6.單例模式
        只允許實例化一次的對象類,只存在一個對象
        爲一個對象規劃一個命名空間,來井井有條的管理對象上的屬性和方法
        爲了代碼易懂,採用語義化,但是能用的詞是有限的,很容易重複
        可以使用命名空間來約束每個人定義的變量
        比如常見的jQuery使用它的方法必須使用它的命名空間
   

     var A = {
            Util : {
                util_method1 : function(){},
                util_method2 : function(){}
                //...
            },
            Tool : {
                tool_method1 : function(){},
                tool_method2 : function(){}
                //...
            },
            Ajax : {
                get : function(){},
                post : function(){}
                //...
            }
        }