一、工廠模式
function person (name,age) {
var p=new Object();
p.name=name;
p.age=age;
p.showMessage=function(){
console.log("name:"+this.name+" age:"+this.age);
}
return p;
}
var p1=person("k1",28);
var p2=person("k2",29);
console.log(p1.showMessage==p2.showMessage);//false 不是同一個showMessage方法
console.log(p1.constructor);//[object] 都是object
工廠模式的缺陷是：沒解決對象識別的問題，而且每個對象的showMessage方法都不是同一個方法（每個方法在每個對象實例上都重新創建了一遍），增加了開銷
二、構造函數模式
function Person (name,age) {
this.name=name;
this.age=age;
this.showMessage=function(){
console.log("name:"+this.name+" age:"+this.age);
}
}
var p1=new Person("k1",28);
var p2=new Person("k2",29);
console.log(p1.showMessage==p2.showMessage);//false 不是同一個showMessage方法
console.log(p1.constructor);//[Person]
console.log(p1 instanceof Person);// true
構造函數模式解決了對象識別的問題，但是每個對象的showMessage方法不是同一個方法（每個方法在每個對象實例上都重新創建了一遍），增加了開銷
三、原型模式
function Person () {
}
Person.prototype.name ="k";
Person.prototype.age =29;
Person.prototype.showMessage=function () {
console.log("name:"+this.name+" age:"+this.age);
};
var p1=new Person();
p1.showMessage();//name:k age:29
var p2=new Person();
p2.showMessage();//name:k age:29
console.log(p1.showMessage==p2.showMessage);// true --引用的是同一函數
console.log(p1.constructor)//[Person] --對象識別
console.log(p1 instanceof Person)//true --對象識別
console.log(Person.prototype.isPrototypeOf(p1));// true
console.log(Object.getPrototypeOf(p1)==Person.prototype);// true
原型模式解決了“每個方法在每個對象實例上都重新創建了一遍”的問題，也解決了對象識別的問題
原型模式有個很大的問題是，因為掛載在函數prototype下面的所有對象、變量、函數都是被該函數的所有實例共享的，雖然通過實例p1、p2可以訪問到prototype的屬性，但是卻不能修改屬性值，例如p1.name="k1"，只是在p1實例上添加了一個name="k1"的屬性，並沒改到prototype.name。如果是值類型還好，如果是引用類型的話，就會有問題了，看如下的例子
function Person () {
};
Person.prototype.age =10;
Person.prototype.array=[1,2,3];
var p1=new Person();
var p2=new Person();
console.log(p1.array);// [1,2,3]
console.log(p2.array); //[1,2,3]
p1.array.push(4);
console.log(p1.array);//[1,2,3,4]
console.log(p2.array);//[1,2,3,4]
p1往array裡面添加了值，在p2也反映出來了，因為他們都是指向同一個array
四、組合使用構造函數模式和原型模式
這是最常見的創建對象的方式，結合了構造函數和原型模式的優點
function Person (name,age) {
this.name=name;
this.age=age;
}
Person.prototype.showMessage = function() {
console.log("name:"+this.name+" age:"+this.age);
};
var p1=new Person("k",30);
p1.showMessage();
五、動態原型模式
主要是解決：把所有的信息都封裝在構造函數中，更符合oo的思想
function Person (name,age) {
this.name=name;
this.age=age;
if(typeof this.showMessage!="function"){
Person.prototype.showMessage=function(){
console.log("name:"+this.name+" age:"+this.age);
}
}
}
var p1=new Person("k",30);
p1.showMessage();
六、寄生構造函數模式
function Person (name,age) {
var o=new Object();
o.name=name;
o.age=age;
o.sayName=function(){
console.log(this.name);
};
return o;
}
var p1=new Person("k",28);
p1.sayName();
寄生構造函數模式和工廠模式是一模一樣的，只不過創建對象的時候使用了new 關鍵字，上例：var p1=new Person("k",28)。
它的主要作用是：在這個構造函數裡面進行功能的擴展，例如，我想定義一個數組類型MyArray，它是以Array數組為基礎的，有一個自己的方法，如下
function MyArray(){
var values=new Array();
values.push.apply(values,arguments);
//自己定義的方法
values.toPipedString=function(){
return this.join('|');
};
return values;
}
var colors=new MyArray("red","blue","green");
console.log(colors.toPipedString());
console.log(colors instanceof Array);
七、穩妥構造函數模式
穩妥構造函數遵循與寄生構造函數類型的模式，但有兩點不同：一是不使用this，二是不使用new 調用構造函數
function Person (name,age) {
var o=new Object();
var tempAge=age;
o.name=name;
o.age=age;
o.sayName=function(){
console.log(name);
}
o.sayAge=function(){
console.log(tempAge);
}
return o;
}
var p1=Person("k1",28);
p1.sayName(); // k1
p1.sayAge(); // 28
p1.name="k2";
p1.age=30;
p1.sayName(); // k1
p1.sayAge(); //28
看到如上的輸出就很好理解什麼叫穩妥對象模式了，就是用這種模式創建的對象，沒有其他辦法能夠改變初始化時候傳入的值，這裡是Person("k1",28)，這樣的對象就是穩妥對象，實際上這裡使用到就是javascript的閉包了。
以上這篇淺析創建javascript對象的方法就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持。