js的建立的幾種模式：

1.工廠模式

//工廠模式
function createPerson(name,age,job){
var o=new Object();
o.name=name;
o.age=age;
o.job=job;
o.sayName=function(){

function Blog(name, url) {
    this.name = name;
    this.url = url;
    this.alertUrl = function() {
        alert(this.url);
    }
}

var blog = new Blog('wuyuchang', 'http://www.cnblogs.com/wuyuchang/');
console.log(blog instanceof Blog);    // true， 判斷blog是不是Blog的實例，即解決了工廠模式中不能

 

 

alert(this.name);
};
return o;
}
var person1=createPerson('shanshan',22,'teacher');
var person2=createPerson('sendie',18,'student');

2.構造函數模式

//構造函數模式
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.sayName = function(){
alert(this.name);
};
}
var person1 = new Person('Nike',29,'teacher');
var person2 = new Person('Arvin',20,'student');

工廠模式與構造函數模式的區別：

1.沒有顯示地建立對象
 
2.直接將屬性和方法賦給了this對象
 
3.沒有return語句
 
4.終於能夠識別的對象的類型。對於檢測對象類型，咱們應該使用instanceof操做符，

5.函數手寫字母要大寫

構造函數雖然好用，但也並不是沒有缺點，使用構造函數的最大的問題在於每次建立實例的時候都要從新建立一次方法（理論上每次建立對象的時候對象的屬性均不一樣，而對象的方法是相同的），然而建立兩次徹底相同的方法是沒有必要的，所以，咱們能夠將函數移到對象外面

 

3.原型模式

function Person(){
              Person.prototype.name="shanshan";
              Person.prototype.age=22;
              Person.prototype.job="teacher";
              Person.prototype.sayName=function(){
                  alert(this.name);
              };
              var person1= new Person();
              var person2= new Person();
              person1.name='sisi';
              alert(person1.name);
              alert(person2.name);
          }

4.混合構造函數模式，與原型模式

function Person(name,age,job){ 

this.name =name;
 this.age = age; 
this.job = job;
}
Person.prototype = { 
constructor:Person, sayName: function(){ alert(this.name); };}var person1 = new Person('Nike',20,'teacher');

function Blog(name, url, friend) {
    this.name = name;
    this.url = url;
    this.friend = friend;
}

Blog.prototype.alertInfo = function() {
    alert(this.name + this.url + this.friend);
}

var blog = new Blog('wuyuchang', 'http://www.cnblogs.com/wuyuchang/', ['fr1', 'fr2', 'fr3']),
    blog2 = new Blog('wyc', 'http://**.com', ['a', 'b']);

blog.friend.pop();
blog.alertInfo();    // wuyuchanghttp://www.cnblogs.com/wuyuchang/fr1,fr2
blog2.alertInfo();    // wychttp://**.coma,b

混合模式中構造函數模式用於定義實例屬性，而原型模式用於定義方法和共享屬性。每一個實例都會有本身的一份實例屬性，但同時又共享着方法，最大限度的節省了內存。另外這種模式還支持傳遞初始參數。優勢甚多。這種模式在ECMAScript中是使用最普遍、認同度最高的一種建立自定義對象的方法。

 

 

 

5.動態原型模式

動態原型模式將全部信息封裝在了構造函數中，而經過構造函數中初始化原型（僅第一個對象實例化時初始化原型），這個能夠經過判斷該方法是否有效而選擇是否須要初始化原型。

　

function Blog(name, url) {
    this.name = name;
    this.url = url;

    if (typeof this.alertInfo != 'function') {
        // 這段代碼只執行了一次
        alert('exe time');
        Blog.prototype.alertInfo = function() {
            alert(thia.name + this.url);
        }
    }
}

var blog = new Blog('wuyuchang', 'http://www.cnblogs.com/wuyuchang'),
    blog2 = new Blog('wyc', 'http:***.com');

　

6.寄生構造函數模式

 當你須要建立一個自定義類型的時候,當前面的隨筆中的模式都不適用的狀況下,可使用寄生構造函數模式。這種模式的基本思想是建立一個函數,該函數的做用僅僅是封裝建立對象的代碼。

代碼以下:

//寄生構造函數模式
function Person(age,name) {
    var o=new Object();
    o.age=age;
    o.name=name;
    o.sayName=function(){
        alert(this.name);
    }
    return o;
}
var person=new Person(22,"張三");
    person.sayName();

//工廠模式
    function createPeron(name,age,job){
        var object=new Object();
        object.name=name;
        object.age=age;
        object.job=job;
        object.sayName=function(){
            alert(this.name);
        }
        object.sayForm=function(){
            alert(typeof this);
        }
        return object;
    }
    var person=createPeron("姍姍",20,"teacher");
    person.sayName();
    person.sayForm();
在上面寄生模式的例子中,Person函數建立了一個新對象,並以相應的屬性和方法初始化該對象,而後又返回這個對象。

而後分析其與工廠模式的區別:

1、寄生模式建立對象時使用了New關鍵字

2、寄生模式的外部包裝函數是一個構造函數

除了上面這2個區別寄生模式和工廠模式幾乎同樣,構造函數在不返回值的狀況下，默認返回對象的新實例。而經過在構造函數的末尾添加一個return 語句,能夠重寫調用構造函數是返回的值

 

做用:寄生模式能夠在特殊的狀況下爲對象來建立構造函數,緣由在於咱們能夠經過構造函數重寫對象的值，並經過return返回  重寫調用構造函數(建立的對象的實例)以後的對象實例的新的值。

假設咱們想建立一個具備額外方法的特殊數組。因爲不能直接修改Array構造函數,因此咱們可使用寄生模式。代碼以下:

複製代碼
function SpecialArray() {
    //建立數組
    var array=new Array();
    //添加值  arguments獲取的是實參,不是形參,因此SpecialArray()並無形參接收傳遞過來的參數
    array.push.apply(array,arguments);
    array.toPipedString=function(){
        return this.join("|");
    }
    return array;
}
var colors=new SpecialArray("red","blue","black");
alert(colors.toPipedString());  //輸出:red|blue|black
複製代碼
咱們利用寄生構造函數模式,在不修改Array構造函數的狀況下，經過爲Array對象建立構造函數達到修改Array對象的目地；

在分析上面的代碼:

1、var array=new Array();建立了一個Array對象

2、return array;在通過一系列的修改以後返回修改以後的Array對象

3、var colors=new SpecialArray("red","blue","black");　建立了一個SpecialArray對象,接收的確是修改以後的Array對象的實例值

因此return array;返回的對象是Array類型,並且colors接收了這個返回的對象,因此colors並非SpecialArray構造函數的實例,而是Array的實例,下面的代碼能夠說明:

alert(colors instanceof SpecialArray); //輸出:false
alert(colors instanceof Array); //輸出:true
因此,因爲存在上述問題,若是能使用其餘的模式的狀況下,建議不要使用這種模式.

7.

穩妥構造函數模式

道格拉斯 *  克羅克福德 發明了JavaScript中的穩妥對象這個概念.所謂穩妥對象,指的是沒有公共屬性，並且其方法也不引用this的對象。穩妥對象最適合用在一些安全的環境中(這些環境會禁止使用new和this)，或者防止數據被其餘的應用改動。

穩妥構造函數與寄生構造函數模式相似,可是也有兩點區別:

一、穩妥模式不使用new操做符調用構造函數

二、新建立對象的實例方法不引用this

其代碼以下:


function Person(name,age) {
    //建立要返回的對象
    var o=new Object();
    //能夠在這裏定義私有變量和函數
    //添加方法
    o.sayName=function(){
        alert(name);
    }
    //返回對象
    return o;
}
var person=Person("姍姍",20);
    person.sayName();  //使用穩妥構造函數模式只能經過其構造函數內部的方法來獲取裏面的屬性值

上面的代碼定義了一個person變量，裏面保存的是一個穩妥對象,而除了吊用他的sayName()方法外,沒有別的方法能夠訪問其數據成員。即便有其餘的代碼會給這個對象添加方法和數據成員，但也不可能有別的方法訪問到傳入到構造函數中的原始數據。穩妥構造函數模式提供的這種安全性。是的它很是適合在某些安全執行環境中。