JavaScript 中，每個對象（null、undefined 、通過 Object.create(null) 創建出的對象除外）都有一個 [[prototype]] 屬性，這個 [[prototype]] 也叫作對象的原型。JavaScript 中一切皆對象，當我們在創建各種各樣的對象時（null、undefined 、通過 Object.create(null) 創建出的對象除外）：值類型、引用類型、函數甚至原生類型，都會在該對象創建伊始，都會為其分配一個原型屬性。該屬性是一個引用類型，或者說指針，指向另外一個對象。
獲取原型對象
獲取原型對象有兩種方法：
- 通過標準的
Object.getPropertyOf()方法 - 通過對象的
__proto__屬性（非標準，但很多瀏覽器支持）
function Person(name){ this.name = name }
// 創建對象
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)創建出的對象
因此我們無法獲取到他們的原型對象，如果強行獲取或引發錯誤。
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) 創建出來的對象在獲取其原型時，Object.getPropertyOf() 和 __proto__ 屬性有點差異：
let c = Object.create(null)
Object.getPropertyOf(a) //null
c.__proto__ //undefined
JavaScript 是基于原型繼承
JavaScript 中的對象都是基于原型繼承來的，每個對象中都保存了一個指針，指向該對象的原型對象。通過在原型對象上添加屬性和方法后，可以讓子對象繼承以實現代碼復用。
Object.create() 方法
通過 Object.create() 方法可以創建對象，該方法接受一個對象作為原型，返回一個基于該原型對象創建出來的對象。
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 創建出來的，因此他們共享了 getName() 方法。
以上就是所謂的原型模式了，JavaScript 中所有的對象都是這樣創建出來的。
構造函數的 prototype 屬性
每個函數都有一個 prototype 屬性，該屬性是一個指針，指向一個對象，在通過 new 操作符創建對象時，會將函數的 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"
默認每個函數的 prototype 都會有一個 constructor，該屬性指向函數本身。我們在創建出來的對象上可以訪問到這個屬性：
person1.constructor === Person //true
person1.constructor === person2.constructor //true
構造函數的秘密
現在我們知道，通過 new 操作符調用構造函數創建對象只是一個障眼法，這個“構造函數”并非是一個真正意義上的類，其創建出的對象和構造函數本身并沒有直接的關系，而只是將構造函數上的一個 prototype 屬性作為自身的原型而已。
這個 new 操作符只是為了對其他面向對象語言中創建對象進行視覺上的模擬而已。
下面再來梳理一下使用構造函數創建對象的過程：
- 以函數的
prototype屬性為原型創建一個空對象 - 把構造函數的執行上下文賦值（
this）給這個對象 - 通過
this在函數內部進行屬性、方法的添加 - 執行完畢，返回該對象
屬性的查找
JavaScript 中，每個對象都是以某一個對象作為原型構造的，而這個原型對象也是由另外一個對象構成的...對象在進行屬性查找時，會首先在自身上進行查找，找到就停止。如果沒有找到，就去該對象的原型對象上查找，如果也沒有找到，就去原型對象的原型對象上查找，一直找到 Object.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.showName = function(){ console.log("hahaha~") }
person1.showName() //"hahaha~"
person2.showName() //"JACK"
原型的動態性
原型是具有動態性的，什么叫動態呢？就是說對象每次讀取數據時，都會在原型鏈上進行一次搜索，而不會有緩存會副本之類的機制。，因此，在原型上做的任何改變都可以從實例上反映出來。
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 () //"我不是黃蓉"
原型鏈一經創建不會更改
對象之所以能找到通過原型鏈搜索屬性，就是因為其保存了其原型對象的一個指針，這個指針始終指向原型對象所在的內存空間，對象一旦創建，其原型鏈就確定好，不會再更改了。
// 定義原型對象
let protoObj = { name:"MIKE" }
// 基于原型對象創建對象
let person = Object.create(protoObj)
person.name // "MIKE"
上面我們創建了一個對象 protoObj，并以此對象為原型創建了一個對象，于是新建對象可以獲取到原型對象上的屬性。
再進一步，如果我們將 protoObj 指向另一個對象，會發生什么情況呢？
protoObj = { name:"JACK" }
person.name // "MIKE"
納尼？居然還是 MIKE？？？上面不是說原型具有動態性嗎？為什么 person 的 name 屬性還是之前的屬性呢？魔方，容我慢慢解釋。
上面的代碼流程是這樣的：
- 在堆內存中開辟了一塊內存空間，放入了
{ name:"JACK" }這個玩意 - 創建了一個
protoObj變量，指向了前面創建的堆內存空間 - 基于
protoObj創建了一對象，該對象的原型屬性復制了protoObj中保存的內存地址，同樣指向了上面那塊堆內存 - 查找屬性時，通過對象原型屬性中保存的指針地址，在原型鏈上進行屬性查找（這個原型鏈實際上是一個鏈表~）
- 又開辟了一塊內存空間，放入了
{ name:"JACK" }這個玩意，然后修改protoObj中保存的內存地址，讓其指向這個新創建的堆內存 - 但是，
person對象的原型中存放的地址是沒有改變的，其還是指向第一次創建的堆內存空間。 - 在
person上查找屬性，仍然是按照之前的原型鏈查找，屬性值為MIKE。
這就是上面代碼的執行流程，可見，改變 protoObj 的指向并不會改變 person 對象原型的指向，是不會對 person 對象造成任何影響的。雖然 protoObj 的引用斷開，但是 person 原型的引用并沒有斷開，因此不會對第一次創建對象時占用的堆內存空間進行垃圾回收，person 仍然可以訪問到這塊內存空間中的內容。因此，除了使用 __proto__ 屬性重新引用新的原型對象，person 對象的原型是不會改變的。
但是，改變 protoObj 的指向后，再基于其創建的對象，就會按照新的原型鏈查找屬性啦：
let person2 = Object.create(protoObe)
person2.name // "JACK"
person.name // "MIKE"
上面說了一大推，不知道您看明白沒有，這里再總結一下：
- 對象已經創建，其原型屬性對原型對象的引用就不會改變，除非使用
__proto__手動進行修改 - 如果一個用來創建對象的原型對象（這里是
protoObj）改變了引用，對已經創建好的對象不會有任何影響 - 但是，如果原型對象（這里是
protoObj）發生改變后，基于其創建的新對象將會應用新的原型對象 - 原型具有動態性的前提是：對象所依賴的原型對象（這里是
protoObj）對堆內存空間的指向不變 - 所謂原型鏈，其實就是一個一個的鏈表
總結
本文主要講到了對象的原型，任何對象都是基于一個原型對象創建出來的，以及揭示了使用構造函數創建對象的障眼法，還講到了原型的動態性和不可修改性。其中，原型的不可修改性的本質是 JavaScript 中的引用類型數據是按照引用賦值，我們對引用類型變量所做的修改，其實是通過變量中保存的內存地址對原始內存進行修改，理解了這個，其他就好理解了。
關于原型的內容還有一些，這里為了節約篇幅，就不往下寫了，下篇文章繼續。
完。
