js建立對象的6種方式總結

一、new 操做符 + Object 建立對象

var person = new Object();
    person.name = "lisi";
    person.age = 21;
    person.family = ["lida","lier","wangwu"];
    person.say = function(){
        alert(this.name);
    }

二、字面式建立對象

var person ={
        name: "lisi",
        age: 21,
        family: ["lida","lier","wangwu"],
        say: function(){
            alert(this.name);
        }
    };

以上兩種方法在使用同一接口建立多個對象時，會產生大量重複代碼，爲了解決此問題，工廠模式被開發。

三、工廠模式

function createPerson(name,age,family) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.family = family;
    o.say = function(){
        alert(this.name);
    }
    return o;
}

var person1 =  createPerson("lisi",21,["lida","lier","wangwu"]);   //instanceof沒法判斷它是誰的實例，只能判斷他是對象，構造函數均可以判斷出
var person2 =  createPerson("wangwu",18,["lida","lier","lisi"]);
console.log(person1 instanceof Object);                           //true

工廠模式解決了重複實例化多個對象的問題，但沒有解決對象識別的問題（可是工廠模式卻無從識別對象的類型，由於所有都是Object，不像Date、Array等，本例中，獲得的都是o對象，對象的類型都是Object，所以出現了構造函數模式）。

四、構造函數模式

function Person(name,age,family) {
    this.name = name;
    this.age = age;
    this.family = family;
    this.say = function(){
        alert(this.name);
    }
}
var person1 = new Person("lisi",21,["lida","lier","wangwu"]);
var person2 = new Person("lisi",21,["lida","lier","lisi"]);
console.log(person1 instanceof Object); //true
console.log(person1 instanceof Person); //true
console.log(person2 instanceof Object); //true
console.log(person2 instanceof Person); //true
console.log(person1.constructor);      //constructor 屬性返回對建立此對象的數組、函數的引用

對比工廠模式有如下不一樣之處：

一、沒有顯式地建立對象

二、直接將屬性和方法賦給了 this 對象

三、沒有 return 語句

以此方法調用構造函數步驟：

一、建立一個新對象

二、將構造函數的做用域賦給新對象（將this指向這個新對象）

三、執行構造函數代碼（爲這個新對象添加屬性）

四、返回新對象 ( 指針賦給變量person ？？？ )

能夠看出，構造函數知道本身從哪裏來（經過 instanceof 能夠看出其既是Object的實例，又是Person的實例）

構造函數也有其缺陷，每一個實例都包含不一樣的Function實例（ 構造函數內的方法在作同一件事，可是實例化後卻產生了不一樣的對象，方法是函數 ，函數也是對象）

所以產生了原型模式

五、原型模式

function Person() {
}

Person.prototype.name = "lisi";
Person.prototype.age = 21;
Person.prototype.family = ["lida","lier","wangwu"];
Person.prototype.say = function(){
    alert(this.name);
};
console.log(Person.prototype);   //Object{name: 'lisi', age: 21, family: Array[3]}

var person1 = new Person();        //建立一個實例person1
console.log(person1.name);        //lisi

var person2 = new Person();        //建立實例person2
person2.name = "wangwu";
person2.family = ["lida","lier","lisi"];
console.log(person2);            //Person {name: "wangwu", family: Array[3]}
// console.log(person2.prototype.name);         //報錯
console.log(person2.age);              //21

原型模式的好處是全部對象實例共享它的屬性和方法（即所謂的共有屬性），此外還能夠如代碼第16,17行那樣設置實例本身的屬性（方法）（即所謂的私有屬性），能夠覆蓋原型對象上的同名屬性（方法）。

六、混合模式（構造函數模式+原型模式）

構造函數模式用於定義實例屬性，原型模式用於定義方法和共享的屬性

function Person(name,age,family){
    this.name = name;
    this.age = age;
    this.family = family;
}

Person.prototype = {
    constructor: Person,  //每一個函數都有prototype屬性，指向該函數原型對象，原型對象都有constructor屬性，這是一個指向prototype屬性所在函數的指針
    say: function(){
        alert(this.name);
    }
}

var person1 = new Person("lisi",21,["lida","lier","wangwu"]);
console.log(person1);
var person2 = new Person("wangwu",21,["lida","lier","lisi"]);
console.log(person2);

能夠看出，混合模式共享着對相同方法的引用，又保證了每一個實例有本身的私有屬性。最大限度的節省了內存。

高程中還提到了動態原型模式，寄生構造函數模式，穩妥構造函數模式。