一、一般來說诵叁，最簡單的創(chuàng)建方式就是字面量方式

var animal = {
  name:'animal',
  speed:12雁竞，
  run:function(){ 
       alert(this.speed)       
     }
}

或是創(chuàng)建一個Object實例，再給他添加屬性和方法

var animal = new Object()
animal.name = 'animal'
animal.speed = '12'
animal.run = function(){
  alert(this.speed)    
}

缺點：很明顯黎休，當(dāng)需要創(chuàng)建多個對象時浓领，會有大量的代碼重寫出現(xiàn)，為了解決這個問題势腮，工廠模式是個很好的辦法联贩。

二、 工廠模式

用函數(shù)封裝實現(xiàn)創(chuàng)建對象具體細(xì)節(jié)的接口捎拯，如：

function createAnimal(name,speed){
    var obj = new Object()
    obj.name = 'animal'
    obj.speed = '12'
   obj.run = function(){
      alert(this.speed)    
    }
return obj
}

函數(shù)createAnimal 根據(jù)傳入的具體參數(shù)來構(gòu)建一個包含必要信息的animal對象泪幌，每次調(diào)用該函數(shù)，只需要傳入必要的參數(shù)即可署照。
缺點：每個創(chuàng)建出來的對象的類型都是Object祸泪，不能判斷其歸屬對象

三、構(gòu)造函數(shù)模式

創(chuàng)建自定義的構(gòu)造函數(shù)建芙，然后可以設(shè)置自定義對象類型的屬性和方法没隘，如，

function Animal(name,speed){
    this.name = name
    this.speed = speed
    this.run = function(){
        alert(this.speed)
    }
}
var animal1 = new Animal('老虎',120)

注：構(gòu)造函數(shù)以大寫字母開頭,非構(gòu)造函數(shù)以小寫字母開頭
新創(chuàng)建的對象都會有一個constructor（構(gòu)造函數(shù)）屬性禁荸，用來標(biāo)明它的對象類型

alert(animal1.constructor == Animal)//true

但檢驗對象類型時右蒲，一般用instanceof操作符

alert(animal1 instanceof Object)//true
alert(animal1 instanceof Animal)//true

這說明例子里創(chuàng)建出來的對象既是Object的實例，又是Animal的實例
缺點：每次實例化時赶熟，實例上的方法就會重新創(chuàng)建一遍瑰妄。相當(dāng)于每次都創(chuàng)建一個Function的實例，然而創(chuàng)建多個完成相同任務(wù)的Function實例完全沒有必要映砖，所以我們可以吧函數(shù)的定義放到構(gòu)造函數(shù)外面來解決這個問題间坐。

function Animal(name,speed){
    this.name = name
    this.speed = speed
    this.run = run
}
function run(){
  alert(this.speed)
}

將run函數(shù)的定義設(shè)置在構(gòu)造函數(shù)之外，也就是全局定義下的函數(shù)邑退，由于run函數(shù)里包含了一個指向函數(shù)的指針竹宋，解決了多個函數(shù)做一件事的問題，擔(dān)心的問題又來了地技，雖然run函數(shù)定義在全局逝撬，但他只應(yīng)該被Animal調(diào)用，應(yīng)該是局部的函數(shù)乓土，但現(xiàn)在其他的對象函數(shù)都可以調(diào)用它，這就暴露了構(gòu)造函數(shù)的內(nèi)部方法，毫無封裝性可言浑玛，原型模式正好可言解決這個問題昼伴。

四呀癣、原型模式

我們每次創(chuàng)建的函數(shù)都會有一個默認(rèn)prototype（原型）屬性，它是一個指向原型對象的指針尽棕，原型對象就是包含構(gòu)造函數(shù)里所有實例共享的屬性和方法的對象。所以通過使用原型對象可以實現(xiàn)屬性和方法的共用彬伦，例：

function Animal(){
}
Animal.prototype.name = "老虎"
Animal.prototype.speed = "120"
Animal.prototype.run = function(){
    alert(this.speed)
}
var  animal1 = new Animal()
animal1.run()//120
var animal2 = new Animal()
animal.run()//120

以之前的Animal構(gòu)造函數(shù)和Animal.prototype創(chuàng)建實例的代碼為例滔悉，下圖展現(xiàn)了各個對象之間的關(guān)系。

image

簡單來說单绑，在創(chuàng)建了自定義的構(gòu)造函數(shù)后回官，該函數(shù)會自動獲得一個prototype屬性，這個屬性指向的就是它的原型對象搂橙。而在默認(rèn)情況下歉提，所有的原型對象也都會自動獲得一個constructor（構(gòu)造函數(shù)）屬性，該屬性指向的是該原型對象的構(gòu)造函數(shù)区转。即Animal.prototype.constructor = Animal

判斷一個屬性或是方法是否存在于原型當(dāng)中（isPrototypeOf()）

alert(Animal.prototype.isPrototypeOf(animal1))//true
ES5中增加了個新方法苔巨，Object.getPrototypeOf（)用于獲得一個對象的原型
alert（Object.getPrototypeOf(animal1) == Animal.prototype）// true
alert(Object.grtPrototypeOf(animal1).name) //'老虎'

如果我們需要修改原型中的值，通過實例重寫是不可以的废离，我們只會在實例中創(chuàng)建一個名稱相同的屬性侄泽，同時屏蔽掉原型中的那個屬性，我們可以試著去驗證看看蜻韭，

var animal1 = new Animal()
var animal2 = new Animal()
animal1.name = "獅子"
alert（animal1.name）''獅子" --實例中新增的屬性
alert(animal2.name)// "老虎" -- 原型中的屬性

所以很自然的我們可以發(fā)現(xiàn)實例屬性讀值的順序：先在實例屬性當(dāng)中搜索該屬性悼尾，如果存在，就返回該值湘捎；如果沒有诀豁，就去實例的原型當(dāng)中搜索。

所以如果我們需要獲取原型當(dāng)中的屬性窥妇，那么實例中就不可以有該屬性舷胜，即便該屬性的值設(shè)為null，但這個屬性依然存在于實例當(dāng)中活翩，我們也無法訪問原型中的該屬性烹骨。delete操作符可以徹底刪除實例中的該屬性，我們也就可以自然的訪問到原型當(dāng)中的該屬性了材泄。例：繼上面例子

delete animal1.name
alert（animal1.name）// "老虎"--原型當(dāng)中的屬性

那當(dāng)我們獲得了一個屬性時沮焕，我們想知道它是來自實例還是來自原型時，該怎么判斷呢拉宗？

hasOwnProperty（）方法就可以做到峦树，它可以檢測一個屬性是來自實例還是原型辣辫，只有當(dāng)給定屬性來自于對象的實例中它才回返回true。

var animal1 = new Animal()
var animal2 = new Animal()
alert(animal1.hasOwnProperty("name"))//false
animal1.name = "獅子"
alert（animal1.name）''獅子" --實例中新增的屬性
alert(animal1.hasOwnProperty("name"))//true
alert(animal2.name)// "老虎" -- 原型中的屬性
alert(animal2.hasOwnProperty("name"))//false

但問題來了魁巩，該怎么判斷一個屬性是否是存在于原型鏈當(dāng)中的呢急灭？僅憑hasOwnProperty()返回值為false并不能判斷，因為這個屬性可能既不在實例也不在原型當(dāng)中谷遂。
我們可以使用in操作符葬馋，in操作符會在通過對象能夠訪問到給定屬性時返回true，無論該對象是否存在于實例中還是原型中肾扰。使用hasOwnProperty（）方法和in操作符畴嘶，就可以確定該屬性是否存在于原型當(dāng)中，

function hasPrototypeProperty(obj,name){
    return ?obj.hasOwnPreperty(name) && (name in obj)
}

原型 -- 字面量創(chuàng)建

在原型創(chuàng)建對象時集晚，我們可以發(fā)現(xiàn)每次添加屬性和方法時窗悯，都要重復(fù)敲Animal.prototype。為了減少代碼重復(fù)量（省事）甩恼，也從視覺上更好的封裝原型的功能蟀瞧，我們可以用一個包裝了所有屬性和方法的對象字面量來重寫整個原型對象，如：

function Animal(){
}
Animal.prototype = {
    name : "老虎",
    speed:120,
    run : function(){
        alert(this.speed)
   }
}

雖然我們將Animal.prototype設(shè)置為等于一個以字面量形式創(chuàng)建的新對象条摸，最終結(jié)果相同悦污，但有一個問題，constructor不再指向Animal钉蒲，而是Object切端。我們可以手動設(shè)置constructor屬性

Animal.prototype = {
    constructor：Animal，
    name : "老虎",
    speed:120,
    run : function(){
        alert(this.speed)
   }
}

缺點：①沒有為構(gòu)造函數(shù)傳遞參數(shù)初始化顷啼，所有的實例默認(rèn)獲得相同的屬性值
②共享特性踏枣，由于所有的原型屬性都被實例共享，如果某個實例需要更改其中一個屬性钙蒙，其他所有實例的該屬性值也會被修改茵瀑，就不一定是我們想要的結(jié)果了。

五躬厌、構(gòu)造函數(shù)和原型模式組合使用

構(gòu)造函數(shù)模式用于定義實例屬性马昨，原型模式用于定義共享的方法和屬性，這樣每個實例都有自己單獨的實例屬性扛施，同時又有對共享方法屬性的引用鸿捧。

function Animal(name,speed){
    this.name = name
    this.speed = speed
    friends = ["one","two"]
    this.run = function(){
        alert(this.speed)
    }
}
Animal.prototype = {
    constructor : Animal
    family:["tom","jery"]
}
var animal1 = new Animal("老虎",120)
var animal2 = new Animal("獅子",130)
animal1.frirends.push("three")
alert(animal1.friends)// ["one","two","three"]
alert(animal1.friends)// ["one","two"]

動態(tài)原型模式

構(gòu)造函數(shù)初次調(diào)用時，通過判斷某個屬性或方法是否存在疙渣，來決定是否需要初始化原型

function Animal(name,speed){
   this.name = name
   this.speed = speed
   friends = ["one","two"]
   if(typeof this.run != 'function'){
       Animal.prototype.run= function(){
           alert(this.speed)
       }
   }
}

七匙奴、寄生構(gòu)造函數(shù)

除了使用new操作盒并把包裝函數(shù)稱為構(gòu)造函數(shù)外，該模式和工廠模式一模一樣妄荔，他的作用也僅僅是封裝創(chuàng)建對象的代碼泼菌。

function Animal(name,speed){
    var obj = new Object()
   obj.name = name
   obj.speed = speed
   obj.run = function(){
        alert(this.speed)
    }
return obj
}

注：寄生構(gòu)造函數(shù)模式返回的對象與構(gòu)造函數(shù)和構(gòu)造函數(shù)的原型沒有關(guān)系谍肤，所以不能依靠instanceof操作符來確定對象類型