JavaScript創建對象的方式有很多，通過Object構造函數或對象字面量的方式也可以創建單個對象，顯然這兩種方式會產生大量的重復代碼，並不適合量產。接下來介紹七種非常經典的創建對象的方式，他們也各有優缺點。

工廠模式

 1 function createPerson(name, job) {
 2   var o = new Object()
 3   o.name = name
 4   o.job = job
 5   o.sayName = function() {
 6     console.log(this.name)
 7   }
 8   return o
 9 }
10 var person1 = createPerson(‘Jiang‘, ‘student‘)
11 var person2 = createPerson(‘X‘, ‘Doctor‘)

可以無數次調用這個工廠函數，每次都會返回一個包含兩個屬性和一個方法的對象

工廠模式雖然解決了創建多個相似對象的問題，但是沒有解決對象識別問題，即不能知道一個對象的類型

構造函數模式

1 function Person(name, job) {
2   this.name = name
3   this.job = job
4   this.sayName = function() {
5     console.log(this.name)
6   }
7 }
8 var person1 = new Person(‘Jiang‘, ‘student‘)
9 var person2 = new Person(‘X‘, ‘Doctor‘)

沒有顯示的創建對象，使用new來調用這個構造函數，使用new後會自動執行如下操作

• 創建一個新對象

• 這個新對象會被執行[[prototype]]鏈接

• 這個新對象會綁定到函數調用的this

• 返回這個對象

使用這個方式創建對象可以檢測對象類型

1 person1 instanceof Object // true
2 person1 instanceof Person //true

但是使用構造函數創建對象，每個方法都要在每個實例上重新創建一次

原型模式

1 function Person() {
2 }
3 Person.prototype.name = ‘Jiang‘
4 Person.prototype.job = ‘student‘
5 Person.prototype.sayName = function() {
6   console.log(this.name)
7 }
8 var person1 = new Person()

將信息直接添加到原型對象上。使用原型的好處是可以讓所有的實例對象共享它所包含的屬性和方法，不必在構造函數中定義對象實例信息。

原型是一個非常重要的概念，在一篇文章看懂proto和prototype的關系及區別中講的非常詳細

更簡單的寫法

 1 function Person() {
 2 }
 3 Person.prototype = {
 4   name: ‘jiang‘,
 5   job: ‘student‘,
 6   sayName: function() {
 7     console.log(this.name)
 8   }
 9 }
10 var person1 = new Person()

將Person.prototype設置為等於一個以對象字面量形式創建的對象，但是會導致.constructor不在指向Person了。

使用這種方式，完全重寫了默認的Person.prototype對象，因此 .constructor也不會存在這裏

1 Person.prototype.constructor === Person  // false

如果需要這個屬性的話，可以手動添加

 1 function Person() {
 2 }
 3 Person.prototype = {
 4   constructor：Person
 5   name: ‘jiang‘,
 6   job: ‘student‘,
 7   sayName: function() {
 8     console.log(this.name)
 9   }
10 }

不過這種方式還是不夠好，應為constructor屬性默認是不可枚舉的，這樣直接設置，它將是可枚舉的。所以可以時候，Object.defineProperty方法

1 Object.defineProperty(Person.prototype, ‘constructor‘, {
2   enumerable: false,
3   value: Person
4 })

缺點

使用原型，所有的屬性都將被共享，這是個很大的優點，同樣會帶來一些缺點

原型中所有屬性實例是被很多實例共享的，這種共享對於函數非常合適。對於那些包含基本值的屬性也勉強可以，畢竟實例屬性可以屏蔽原型屬性。但是引用類型值，就會出現問題了

 1 function Person() {
 2 }
 3 Person.prototype = {
 4   name: ‘jiang‘,
 5   friends: [‘Shelby‘, ‘Court‘]
 6 }
 7 var person1 = new Person()
 8 var person2 = new Person()
 9 person1.friends.push(‘Van‘)
10 console.log(person1.friends) //["Shelby", "Court", "Van"]
11 console.log(person2.friends) //["Shelby", "Court", "Van"]
12 console.log(person1.friends === person2.friends) // true

friends存在與原型中，實例person1和person2指向同一個原型，person1修改了引用的數組，也會反應到實例person2中

組合使用構造函數模式和原型模式

這是使用最為廣泛、認同度最高的一種創建自定義類型的方法。它可以解決上面那些模式的缺點

使用此模式可以讓每個實例都會有自己的一份實例屬性副本，但同時又共享著對方法的引用

這樣的話，即使實例屬性修改引用類型的值，也不會影響其他實例的屬性值了

 1 function Person(name) {
 2   this.name = name
 3   this.friends = [‘Shelby‘, ‘Court‘]
 4 }
 5 Person.prototype.sayName = function() {
 6   console.log(this.name)
 7 }
 8 var person1 = new Person()
 9 var person2 = new Person()
10 person1.friends.push(‘Van‘)
11 console.log(person1.friends)  //["Shelby", "Court", "Van"]
12 console.log(person2.friends) // ["Shelby", "Court"]
13 console.log(person1.friends === person2.friends) //false

動態原型模式

動態原型模式將所有信息都封裝在了構造函數中，初始化的時候，通過檢測某個應該存在的方法時候有效，來決定是否需要初始化原型

 1 function Person(name, job) {
 2   // 屬性
 3   this.name = name
 4   this.job = job
 5  
 6   // 方法
 7   if(typeof this.sayName !== ‘function‘) {
 8     Person.prototype.sayName = function() {
 9        console.log(this.name)
10     }
11   }
12  
13 }
14 var person1 = new Person(‘Jiang‘, ‘Student‘)
15 person1.sayName()

只有在sayName方法不存在的時候，才會將它添加到原型中。這段代碼只會初次調用構造函數的時候才會執行。

此後原型已經完成初始化，不需要在做什麽修改了

這裏對原型所做的修改，能夠立即在所有實例中得到反映

其次，if語句檢查的可以是初始化之後應該存在的任何屬性或方法，所以不必用一大堆的if語句檢查每一個屬性和方法，只要檢查一個就行

寄生構造函數模式

這種模式的基本思想就是創建一個函數，該函數的作用僅僅是封裝創建對象的代碼，然後再返回新建的對象

 1 function Person(name, job) {
 2   var o = new Object()
 3   o.name = name
 4   o.job = job
 5   o.sayName = function() {
 6     console.log(this.name)
 7   }
 8   return o
 9 }
10 var person1 = new Person(‘Jiang‘, ‘student‘)
11 person1.sayName()

這個模式，除了使用new操作符並把使用的包裝函數叫做構造函數之外，和工廠模式幾乎一樣

構造函數如果不返回對象，默認也會返回一個新的對象，通過在構造函數的末尾添加一個return語句，可以重寫調用構造函數時返回的值

穩妥構造函數模式

首先明白穩妥對象指的是沒有公共屬性，而且其方法也不引用this。

穩妥對象最適合在一些安全環境中（這些環境會禁止使用this和new），或防止數據被其他應用程序改動時使用

穩妥構造函數模式和寄生模式類似，有兩點不同:一是創建對象的實例方法不引用this，而是不使用new操作符調用構造函數

 1 function Person(name, job) {
 2   var o = new Object()
 3   o.name = name
 4   o.job = job
 5   o.sayName = function() {
 6     console.log(name)
 7   }
 8   return o
 9 }
10 var person1 = Person(‘Jiang‘, ‘student‘)
11 person1.sayName()

和寄生構造函數模式一樣，這樣創建出來的對象與構造函數之間沒有什麽關系，instanceof操作符對他們沒有意義

補充：JavaScript 創建對象的七種方式