JavaScript 中然走，每個對象（null携兵、undefined 辅斟、通過 Object.create(null) 創(chuàng)建出的對象除外）都有一個 [[prototype]] 屬性靖诗，這個 [[prototype]] 也叫作對象的原型。JavaScript 中一切皆對象沪斟，當我們在創(chuàng)建各種各樣的對象時（null广辰、undefined 、通過 Object.create(null) 創(chuàng)建出的對象除外）：值類型主之、引用類型择吊、函數(shù)甚至原生類型，都會在該對象創(chuàng)建伊始槽奕，都會為其分配一個原型屬性干发。該屬性是一個引用類型，或者說指針史翘，指向另外一個對象。
獲取原型對象
獲取原型對象有兩種方法：
- 通過標準的
Object.getPropertyOf()方法 - 通過對象的
__proto__屬性（非標準冀续，但很多瀏覽器支持）
function Person(name){ this.name = name }
// 創(chuàng)建對象
let arr = []
let str = ""
let obj = {}
let person = new Person("MIKE")
// 獲取對象的原型 通過 Object.getPropertyOf() 方法
Object.getPropertyOf(arr)
Object.getPropertyOf(str)
Object.getPropertyOf(obj)
Object.getPropertyOf(person)
// 獲取對象的原型 通過 __proto__ 屬性
arr.__proto__
str.__proto__
obj.__proto__
person.__proto__
通過上面的方式可以獲取任意對象的原型琼讽。
沒有原型的對象
JavaScript 有以下幾種對象是沒有原型的：
undefinednull- 通過
Object.create(null)創(chuàng)建出的對象
因此我們無法獲取到他們的原型對象，如果強行獲取或引發(fā)錯誤洪唐。
let a = undefined
let b = null
a.__proto__ //Uncaught TypeError: Cannot read property '__proto__' of undefined
Object.getProertyOf(b) //Uncaught TypeError: Cannot convert undefined or null to object
通過 Object.create(null) 創(chuàng)建出來的對象在獲取其原型時钻蹬，Object.getPropertyOf() 和 __proto__ 屬性有點差異：
let c = Object.create(null)
Object.getPropertyOf(a) //null
c.__proto__ //undefined
JavaScript 是基于原型繼承
JavaScript 中的對象都是基于原型繼承來的，每個對象中都保存了一個指針凭需，指向該對象的原型對象问欠。通過在原型對象上添加屬性和方法后肝匆，可以讓子對象繼承以實現(xiàn)代碼復用。
Object.create() 方法
通過 Object.create() 方法可以創(chuàng)建對象顺献，該方法接受一個對象作為原型旗国，返回一個基于該原型對象創(chuàng)建出來的對象。
let personProto = {
getName(){
console.log(this.name)
}
}
let person1 = Object.create(personProto)
let person2 = Object.create(personProto)
person1.name = "MIKE"
person2.name = "JACK"
person1.getName() // "MIKE"
person2.getName() // "JACK"
person1.getName === person2.getName //true
以上的 person1 和 person2 都是通過同一個原型 personProto 創(chuàng)建出來的注整，因此他們共享了 getName() 方法能曾。
以上就是所謂的原型模式了，JavaScript 中所有的對象都是這樣創(chuàng)建出來的肿轨。
構造函數(shù)的 prototype 屬性
每個函數(shù)都有一個 prototype 屬性寿冕，該屬性是一個指針，指向一個對象椒袍，在通過 new 操作符創(chuàng)建對象時驼唱，會將函數(shù)的 prototype 屬性作為新建對象的原型。要想新建的對象能夠復用原型上的屬性或方法驹暑，只需在該對象上進行增加即可玫恳。
function Person(name){ this.name = name }
Person.ptototype.showName = function(){ console.log(this.name) }
let person1 = new Person("MIKE")
let person2 = new Person("JACK")
person1.getName() // "MIKE"
person2.getName() // "JACK"
默認每個函數(shù)的 prototype 都會有一個 constructor，該屬性指向函數(shù)本身岗钩。我們在創(chuàng)建出來的對象上可以訪問到這個屬性：
person1.constructor === Person //true
person1.constructor === person2.constructor //true
構造函數(shù)的秘密
現(xiàn)在我們知道纽窟，通過 new 操作符調(diào)用構造函數(shù)創(chuàng)建對象只是一個障眼法，這個“構造函數(shù)”并非是一個真正意義上的類兼吓，其創(chuàng)建出的對象和構造函數(shù)本身并沒有直接的關系臂港，而只是將構造函數(shù)上的一個 prototype 屬性作為自身的原型而已。
這個 new 操作符只是為了對其他面向?qū)ο笳Z言中創(chuàng)建對象進行視覺上的模擬而已视搏。
下面再來梳理一下使用構造函數(shù)創(chuàng)建對象的過程：
- 以函數(shù)的
prototype屬性為原型創(chuàng)建一個空對象 - 把構造函數(shù)的執(zhí)行上下文賦值（
this）給這個對象 - 通過
this在函數(shù)內(nèi)部進行屬性审孽、方法的添加 - 執(zhí)行完畢，返回該對象
屬性的查找
JavaScript 中浑娜，每個對象都是以某一個對象作為原型構造的佑力，而這個原型對象也是由另外一個對象構成的...對象在進行屬性查找時，會首先在自身上進行查找筋遭，找到就停止打颤。如果沒有找到，就去該對象的原型對象上查找漓滔，如果也沒有找到编饺，就去原型對象的原型對象上查找，一直找到 Object.prototype 為止响驴。
我們也可以說透且，對象進行屬性查找時，是按照原型鏈`一層一層進行查找的豁鲤。
原型鏈上的屬性不可修改
對象可以從原型鏈上獲取屬性秽誊，但無法設置或修改原型鏈上的屬性鲸沮。原型鏈的目的讓對象之間能實現(xiàn)屬性方法復用，如果每個對象都能修改其上的屬性锅论，那豈不是亂套了讼溺。
因此原型鏈的機制是這樣的：
- 當對象進行屬性讀取時，如果對象本身沒有這個屬性棍厌，則會在原型鏈上獲取
- 當對象設置屬性時肾胯，不管原型鏈上有沒有這個屬性，都會在對象本身上進行設置耘纱，而不會修改原型鏈
也就是說敬肚，我可以給你，但你不能在我身上動手動腳束析，要動手動腳艳馒，找你自己做試驗把！
function Person(name){ this.name = name }
Person.ptototype.showName = function(){ console.log(this.name) }
let person1 = new Person("MIKE")
let person2 = new Person("JACK")
person1.showName = function(){ console.log("hahaha~") }
person1.showName() //"hahaha~"
person2.showName() //"JACK"
原型的動態(tài)性
原型是具有動態(tài)性的员寇，什么叫動態(tài)呢弄慰？就是說對象每次讀取數(shù)據(jù)時，都會在原型鏈上進行一次搜索蝶锋，而不會有緩存會副本之類的機制陆爽。，因此扳缕，在原型上做的任何改變都可以從實例上反映出來慌闭。
function Person(name){ this.name = name }
Person.ptototype.showName = function(){ console.log(this.name) }
let person1 = new Person("MIKE")
person1.showName ()
// 修改原型對象
Person.ptototype.showName = function(){ console.log("我不是黃蓉") }
person1.showName () //"我不是黃蓉"
原型鏈一經(jīng)創(chuàng)建不會更改
對象之所以能找到通過原型鏈搜索屬性，就是因為其保存了其原型對象的一個指針躯舔，這個指針始終指向原型對象所在的內(nèi)存空間驴剔，對象一旦創(chuàng)建，其原型鏈就確定好粥庄，不會再更改了丧失。
// 定義原型對象
let protoObj = { name:"MIKE" }
// 基于原型對象創(chuàng)建對象
let person = Object.create(protoObj)
person.name // "MIKE"
上面我們創(chuàng)建了一個對象 protoObj，并以此對象為原型創(chuàng)建了一個對象惜互，于是新建對象可以獲取到原型對象上的屬性布讹。
再進一步，如果我們將 protoObj 指向另一個對象训堆，會發(fā)生什么情況呢炒事？
protoObj = { name:"JACK" }
person.name // "MIKE"
納尼？居然還是 MIKE蔫慧？？权薯？上面不是說原型具有動態(tài)性嗎姑躲？為什么 person 的 name 屬性還是之前的屬性呢睡扬？魔方，容我慢慢解釋黍析。
上面的代碼流程是這樣的：
- 在堆內(nèi)存中開辟了一塊內(nèi)存空間卖怜，放入了
{ name:"JACK" }這個玩意 - 創(chuàng)建了一個
protoObj變量，指向了前面創(chuàng)建的堆內(nèi)存空間 - 基于
protoObj創(chuàng)建了一對象阐枣，該對象的原型屬性復制了protoObj中保存的內(nèi)存地址马靠，同樣指向了上面那塊堆內(nèi)存 - 查找屬性時，通過對象原型屬性中保存的指針地址蔼两，在原型鏈上進行屬性查找（這個原型鏈實際上是一個鏈表~）
- 又開辟了一塊內(nèi)存空間甩鳄，放入了
{ name:"JACK" }這個玩意，然后修改protoObj中保存的內(nèi)存地址额划，讓其指向這個新創(chuàng)建的堆內(nèi)存 - 但是妙啃，
person對象的原型中存放的地址是沒有改變的，其還是指向第一次創(chuàng)建的堆內(nèi)存空間俊戳。 - 在
person上查找屬性揖赴，仍然是按照之前的原型鏈查找，屬性值為MIKE抑胎。
這就是上面代碼的執(zhí)行流程燥滑，可見，改變 protoObj 的指向并不會改變 person 對象原型的指向阿逃，是不會對 person 對象造成任何影響的铭拧。雖然 protoObj 的引用斷開，但是 person 原型的引用并沒有斷開盆昙，因此不會對第一次創(chuàng)建對象時占用的堆內(nèi)存空間進行垃圾回收羽历，person 仍然可以訪問到這塊內(nèi)存空間中的內(nèi)容。因此淡喜，除了使用 __proto__ 屬性重新引用新的原型對象秕磷，person 對象的原型是不會改變的。
但是炼团，改變 protoObj 的指向后澎嚣，再基于其創(chuàng)建的對象，就會按照新的原型鏈查找屬性啦：
let person2 = Object.create(protoObe)
person2.name // "JACK"
person.name // "MIKE"
上面說了一大推瘟芝，不知道您看明白沒有易桃，這里再總結一下：
- 對象已經(jīng)創(chuàng)建，其原型屬性對原型對象的引用就不會改變锌俱，除非使用
__proto__手動進行修改 - 如果一個用來創(chuàng)建對象的原型對象（這里是
protoObj）改變了引用晤郑，對已經(jīng)創(chuàng)建好的對象不會有任何影響 - 但是，如果原型對象（這里是
protoObj）發(fā)生改變后，基于其創(chuàng)建的新對象將會應用新的原型對象 - 原型具有動態(tài)性的前提是：對象所依賴的原型對象（這里是
protoObj）對堆內(nèi)存空間的指向不變 - 所謂原型鏈造寝，其實就是一個一個的鏈表
總結
本文主要講到了對象的原型磕洪，任何對象都是基于一個原型對象創(chuàng)建出來的，以及揭示了使用構造函數(shù)創(chuàng)建對象的障眼法诫龙，還講到了原型的動態(tài)性和不可修改性析显。其中，原型的不可修改性的本質(zhì)是 JavaScript 中的引用類型數(shù)據(jù)是按照引用賦值签赃，我們對引用類型變量所做的修改谷异，其實是通過變量中保存的內(nèi)存地址對原始內(nèi)存進行修改，理解了這個锦聊，其他就好理解了歹嘹。
關于原型的內(nèi)容還有一些，這里為了節(jié)約篇幅括丁，就不往下寫了荞下，下篇文章繼續(xù)。
完史飞。
