 function createPerson(name, age){
 var obj = new Object();
 obj.name = name;
 obj.age = age;
 return obj; //一定要返回，否則打印undefined:undefined
 }
 var person1 = new createPerson('Young',18);
 console.log(person1.name + ':' + person1.age);

優(yōu)點：工廠模式可以解決創(chuàng)建多個相似對象

缺點：沒有解決對象識別問題（怎樣確定一個對象的類型）

構造函數(shù)模式

 function Person(name,age){
 this.name = name;
 this.age = age;
 }
 var person1 = new Person('Young',18);
 console.log(person1.name + ':' + person1.age);

在說優(yōu)缺點之前，先來說說她本身的一點小故事吧

將構造函數(shù)當做函數(shù)使用

 function Person(name,age){
 this.name=name;
 this.age=age;
 this.sayName=function(){
 return this.name;
 }
 }
 
 //當做構造函數(shù)使用
 var person1 = new Person('Young', 18);
 person1.sayName();
 console.log(person1.name + ':' + person1.age);
 
 //當做普通函數(shù)調(diào)用
 Person('Wind', 18);
 console.log(window.sayName());
 
 //在另一個作用域中調(diào)用
 var obj = new Object();
 Person.call(obj, 'bird', 100);
 console.log(obj.sayName());

構造函數(shù)優(yōu)缺點

優(yōu)點：可以將它的實例標識為一種特定類型

缺點：每個方法都要在每個實例上重新創(chuàng)建一遍。當然你也可以這樣改：

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

改為調(diào)用全局函數(shù)，這樣一來毫無封裝性可言。。。接下來的原型模式可以彌補這個的不足

原型模式

 function Person(){
 
 }
 Person.prototype.name = 'Young';
 Person.prototype.age = 18;
 Person.prototype.sayName = function(){
 return this.name;
 }
 
 var person1 = new Person();
 console.log(person1.sayName());
 var person2 = new Person();
 console.log(person1.sayName());
 alert(person1.sayName === person2.sayName);
 //person1和person2訪問的是同一組屬性的同一個sayName()函數(shù)

雖然可以通過對象實例訪問保存在原型中的值，但卻不能通過實例對象重寫原型中的值

 function Person(){
 
 }
 Person.prototype.name='Young';
 Person.prototype.age=18;
 Person.prototype.sayName=function(){
 return this.name;
 }
 
 var person1=new Person();
 var person2=new Person();
 person1.name='Wind';
 
 console.log(person1.sayName());//Wind
 console.log(person2.sayName());//Young
 alert(person1.sayName==person2.sayName);//true

在我們調(diào)用person1.sayName的時候，會先后執(zhí)行兩次搜索，解析器先確定實例person1是否有sayName的屬性，有則調(diào)用自己的屬性，沒有則搜索原型中的屬性。

 function Person(){
 
 }
 Person.prototype.name='Young';
 Person.prototype.age=18;
 Person.prototype.sayName=function(){
 return this.name;
 }
 
 var person1=new Person();
 var person2=new Person();
 
 person1.name='Wind';
 console.log(person1.sayName());//Wind
 console.log(person2.sayName());//Young
 
 delete person1.name;
 console.log(person1.sayName());//Young
 console.log(person2.sayName());//Young

使用hasOwnPropertyType方法可以檢測一個屬性是存在與原型中還是存在于實例中，該方法是從Object繼承來的，實例中為true，原型中為false。

枚舉對象上的實例屬性用Object.keys()方法

 function Person(){
 
 }
 Person.prototype.name='Young';
 Person.prototype.age=18;
 Person.prototype.sayName=function(){
 return this.name;
 }
 
 var keys=Object.keys(Person.prototype);
 console.log(keys);//["name", "age", "sayName"]

原型模式優(yōu)缺點

優(yōu)點：不用每個方法都要在每個實例上重申一遍

缺點：很少有人單獨使用原型模式地。。問題詳列

 function Person(){
 
 }
 Person.prototype={
 constructor:Person,
 name:'Young',
 age:18,
 friends:['Big','Pig'],
 sayName:function(){
 return this.name;
 }
 };
 var p1=new Person();
 var p2=new Person();
 p1.friends.push('Mon');
 console.log(p1.friends);//["Big", "Pig", "Mon"]
 console.log(p2.friends);//["Big", "Pig", "Mon"]

正是因為實例一般都要有自己的屬性，而我們這里將他放在了Person.prototype中，所以隨著p1的修改，整個實例包括原型都修改了。那么，我們可以組合使用構造函數(shù)模式和原型模式。

組合使用構造函數(shù)模式和原型模式

 function Person(name,age){
 this.name=name;
 this.age=age;
 this.friends=['Big','Pig'];
 }
 Person.prototype={
 sayName:function(){
 return this.name;
 }
 };
 var p1=new Person('Young',18);
 var p2=new Person('Wind',78);
 p1.friends.push('Raganya');
 console.log(p1.friends);//["Big", "Pig", "Raganya"]
 console.log(p2.friends);//["Big", "Pig"]
 console.log(p1.friends==p2.friends);//false
 console.log(p1.sayName==p2.sayName);//true

這種模式是目前使用最廣泛、認同度最高的一種創(chuàng)建自定義類型的方法。是用來定義引用類型的一種默認模式。

總結

以上就是關于分析Javascript中創(chuàng)建對象方式的全部內(nèi)容，通過這篇文章為大家總結的四種方式和其優(yōu)缺點，希望可以對大家學習使用Javascript能有所幫助。

您可能感興趣的文章: