并不是每個屬性都是可枚舉的，可以使用propertyIsEnumerable()方法檢查一個屬性是否為可枚舉，每個對象都有該方法。
var person1= {name: "Nicholas"}
var properties = Object.keys(person1)
console.log("name" in person1) // true
console.log(person1.propertyIsEnumerable("name")) // true
console.log("length" in properties) // true
console.log(properties.propertiesIsEnumerable("length")) // false
這里name為可枚舉，因為它是person1的自有屬性，而properties的length為不可枚舉的，因為它是Array.prototype的內建屬性，你會發現很多原生屬性默認都是不可枚舉的。
3.5 屬性類型
屬性有兩種類型數據屬性和訪問器屬性；
數據屬性包含一個值，例如之前的name屬性，[[Put]]方法默認行為是創建一個數據屬性。
訪問器屬性不包含值而是定義了一個當屬性被讀取時調用的函數getter和一個當屬性被寫入時調用的函數setter。
let person1 = {
_name: "Nicholas" , // 前置下劃線是約定俗成的，表示該屬性為私有的，實際上它是公開的
get name() {
console.log("reading me")
return this._name
},
set name(val) {
console.log(`setting name to ${val}`)
this._name = val
}
}
console.log(person1.name) // reading me Nicholas
person1.name="greg"
console.log(person1.name) // setting name to Greg
用于定義name的getter和setter的語法看上去像函數但是沒有function關鍵字，注意get和set之后的name需要跟被訪問的屬性名保持一致。
當你希望賦值操作會觸發一些行為或者讀取的值需要通過計算所需的返回值得到時，訪問器屬性將會很有用。
注意： 不一定要同時定義getter和setter，可以選擇其中之一，如果只定義getter，那么屬性變為只讀，在非嚴格下寫入將失敗，嚴格下寫入報錯，如果只定義setter，那么屬性為只寫，兩種模式下讀取都失敗
3.6 屬性特征
ES5之前無法訪問屬性的任何特征，也沒有辦法指定一個屬性是否為可枚舉，因此ES5引入多種方法與屬性特征互動，同時也引入新的特征來支持額外的功能，現在已經可以創建出和Js內建屬性一樣的自定義屬性。下面介紹數據屬性和訪問器屬性的特征。
3.6.1 通用特征
有兩個屬性時數據屬性和訪問器屬性共有的：
[[Enumerable]]決定你是否可以遍歷該屬性；
[[Configurable]]決定該屬性是否可配置；
你可以用delete刪除一個可配置的屬性，或者隨時改變它，也可以把可配置的屬性從數據屬性變為訪問器屬性，反之亦可，所有自有屬性都是可枚舉和可配置的。
如果你想改變屬性特征，可以使用Object.defineProperty()方法，它接受三個參數：擁有函數的對象、屬性名、包含需要設置的特征的屬性描述對象。屬性描述對象具有和內部特征同名的屬性但名字中不包含中括號，所以可以使用enumerable屬性來設置[[Enumerable]]特征，用configurable屬性來設置[[Configurable]]特征。假如你想讓一個對象屬性變成不可枚舉且不可配置：
var person1 = { name: "Nicholas" }
var properties = Object.keys(person1)
Object.defineProperty(person1, "name", { enumerable: false })
console.log("name" in person1) // true
console.log(person1.propertyIsEnumerable("name")) // false
console.log(properties.length) // 0
Object.defineProperty(person1, "name", { configurable: false })
delete person1.name // 屬性設置為不可配置之后不能被delete，刪除失敗
console.log("name" in person1) // true
console.log(person1.name) // Nicholas
Object.defineProperty(person1, "name", { configurable: true }) // error! 設置為不可配置之后就不能再設置屬性特征了，包括[[Configurable]]
3.6.2 數據屬性特征
數據屬性額外擁有兩個訪問器屬性不具備的特征：
[[Value]]包含屬性的值，當你在對象上創建屬性時該特征被自動賦值，所有屬性的值都保存在[[Value]]中，哪怕該值是一個函數；
[[Writable]]是一個布爾值，指示該屬性是否可以寫入，所有屬性默認都是可寫的，除非另外指定。
通過這兩個額外屬性，可以使用Object.defineProperty()完整定義一個數據屬性，即使該屬性還不存在。
var person1 = { name: "Nicholas" } // 等同于
Object.defineProperty(person, "name", {
value: "Nicholas",
enumerable: true,
configurable: true,
writable: true
}
當Object.defineProperty()被調用時，它首先檢查屬性是否存在，如果不存在將根據屬性描述對象指定的特征創建。當使用Object.defineProperty()定義新屬性時一定記得為所有的特征指定一個值，否則布爾型的特征會被默認設置為false。
var person1 = {}
Object.defineProperty(person1, "name", { value: "Nicholas" }) // 由于沒有顯式指定特征，因此屬性為不可枚舉、不可配置、不可寫的
console.log("name" in person1) // true
console.log(person1.propertyIsEnumerable("name")) // false
delete person1.name
console.log("name" in person1) // true
person1.name = "Greg"
console.log(person1.name) // Nicholas
在嚴格模式下視圖改變不可寫屬性會拋出錯誤，而在非嚴格模式下會失敗
3.6.3 訪問器屬性
訪問器屬性擁有兩個數據屬性不具備的特征，訪問器屬性不需要儲存值，因此也就沒有[[Value]]和[[Writable]]，取而代之的是[[Get]]和[[Set]]屬性，內含getter和setter函數，同字面量形式一樣，只需要定義其中一個特征就可以創建一個訪問器屬性。
如果試圖創建一個同時具有數據屬性和訪問器屬性的屬性，會報錯
之前get set 例子可以被改寫為：
let person1 = { _name: "Nicholas" }
Object.defineProperty(person1, "name", {
get: function() {
console.log("reading me")
return this._name
},
set: function(val) {
console.log(`setting name to ${val}`)
this._name = val
},
enumerable: true,
configurable: true
}
)
console.log(person1.name) // reading me Nicholas
person1.name = "greg"
console.log(person1.name) // setting name to Greg
注意Object.defineProperty()中的get和set關鍵字，它們是包含函數的數據屬性，這里不能使用字面量形式。
3.6.4 定義多重屬性
如果你使用Object.defineProperties()而不是Object.defineProperty()可以為一個對象同時定義多個屬性，這個方法接受兩個參數：需要改變的對象、一個包含所有屬性信息的對象。后者可以背看成一個哈希表，鍵是屬性名，值是為該屬性定義特征的屬性描述對象。
var person1 = {}
Object.defineProperties(person1, {
_name: {
value: "Nicholas",
enumerable: true,
configurable: true,
writable: true
},
name: {
get: function() {
console.log("reading me")
return this._name
},
set: function(val) {
console.log(`setting name to ${val}`)
this._name = val
},
enumerable: true,
configurable: true
}
})
3.6.5 獲取屬性特征
如果需要獲取屬性的特征，Js中可以使用Object.getOwnPropertyDescriptor()，這個方法只可以用于自有屬性，它接受兩個參數：對象、屬性名。如果屬性存在，它會返回一個屬性描述對象，內含四個屬性：configurable、enumerable、另外兩個根據屬性類型決定。即使你從沒有為屬性顯式指定特征，你依然會得到包含全部這些特征值的屬性描述對象。
3.7 禁止修改對象
對象和屬性一樣具有指導行為的內部特征，其中，[[Extensible]]是一個布爾值，它指明該對象本身是否可以被修改，你創建的所有對象默認都是可擴展的，新的屬性可以隨時被添加，設置[[Extensible]]為false則可以禁止新屬性的添加。
下面有三種方法可以用來鎖定對象屬性
3.7.1 禁止擴展
第一種方法是Object.preventExtensions()創建一個不可擴展的對象。該方法接受一個參數：你希望擴展的對象。一旦在一個對象上用這個方法，就永遠不能再給它添加新的屬性了。
let person1 = { _name: "Nicholas" }
console.log(Object.isExtensible(person1)) // true
Object.preventExtensions(person1)
console.log(Object.isExtensible(person1)) // false
person1.sayName = function(){
console.log(this.name)
}
console.log("sayName" in person1) // false
在嚴格模式下試圖給一個不可擴展對象添加屬性會拋出錯誤，而在非嚴格模式下會失敗。應該對不可擴展對象使用嚴格模式，這樣當一個不可擴展對象被錯誤使用時你就會知道
3.7.2 對象封印
一個被封印的對象是不可擴展的且其所有屬性都不可配置，這意味著不僅不能給對象添加屬性，而且也不能刪除屬性或改變類型（從數據屬性改變成訪問屬性或者反之），如果一個對象被封印，那么只能讀寫它的屬性。
可以用Object.seal()方法來封印一個對象，該方法被調用時[[Extensible]]特征被設置為false，其所有屬性的[[Configurable]]特征被置為false，可以使用Object.isSealed()來判斷一個對象是否被封印。
這段代碼封印了person1，因此不能再person1上添加或者刪除屬性。所有的被封印對象都是不可擴展的對象，此時對person1使用Object.isExtensible()方法將會返回false，且視圖添加sayName()會失敗。
而且雖然person.name被成功改變成一個新值，但是刪除它會失敗。
確保對被封印的對象使用嚴格模式，這樣當有人誤用該對象時，會報錯
3.7.3 對象凍結
被凍結的對象不能添加或刪除屬性，不能修改屬性類型，也不能寫入任何數據屬性。簡言而之，被凍結對象是一個數據屬性都為只讀的被封印對象。
Object.freeze() 凍結對象。
Object.isFrozen() 判斷對象是否被凍結。
被凍結對象僅僅只是對象在某個時間點上的快照，用途有限且很少被使用
4. 構造函數和原型對象
4.1 構造函數
構造函數就是用new創建對象時調用的函數，使用構造函數的好處在于所有用同一個構造函數創建的對象都具有同樣的屬性和方法。
構造函數也是函數，定義的方式和普通函數一樣，唯一的區別是構造函數名應該首字母大寫，以此區分。
function Person(){}
var person1 = new Person // 如果沒有要傳遞給構造函數的參數，括號可以省略
console.log(person1 instanceof Person) // true
console.log(person1.constructor === Person) // true
即使Person構造函數沒有顯式返回任何東西，person1也會被認為是一個新的Person類型的對象，new操作符會自動創建給定類型的對象并返回它們。每個對象在創建時都會自動擁有一個構造函數屬性，其中包含了一個指向其構造函數的引用。那些通過字面量形式或者Object構造函數創建出來的泛用對象，其構造函數屬性constructer指向Object；那些通過自定義構造函數創建出來的對象，其構造函數屬性指向創建它的構造函數。
雖然對象實例及其構造函數之間存在這樣的關系，但是還是建議使用instanceof來檢查對象類型，這是因為構造函數屬性可以被覆蓋，并不一定完全準確。
在構造函數中只需簡單的給this添加任何想要的屬性即可：
function Person(name){
this.name = name
this.sayName() = function(){
console.log(this.name)
}
}
在調用構造函數時，new會自動創建this對象，且其類型就是構造函數的類型，構造函數本身不需要返回一個對象，new操作符會幫你返回。
function Person2(name){
this.name=name
this.sayName=function(){
console.log(this.name)
}
}
var person2=new Person2("sam")
console.log(person2.name) // sam
person2.sayName() // sam
每個對象都有自己的name屬性值，所以sayName可以根據不同對象返回不同的值。
也可以在構造函數中顯式調用return，如果返回的是一個對象，那么它會替代新創建的對象實例返回，如果返回的是一個原始類型，那么它將被忽略，新創建的對象實例將被返回。
構造函數允許使用一致的方法初始化一個類型的實例，在使用對象前設置好所有的屬性，可以在構造函數中使用Object.defineProperty()的方法來幫助初始化。
function Person(name) {
Object.defineProperty(this, "name", {
get: function() {
return name
},
set: function(newName) {
name = newName
},
enumerable: true,
configurable: true
})
this.sayName = function() {
console.log(this.name)
}
}
var person1 =new Person("Nicholas") // 始終確保使用了new操作符，否則就是冒著改變全局對象的風險
console.log(person1 instanceof Person) // true
console.log(typeof person1) // object
console.log(name) // undefined
當Person不是被new調用時候，構造函數中的this指向全局對象，由于Person構造函數依靠new提供返回值，person1變量為undefined。沒有new，Person只不過是一個沒有返回語句的函數，對this.name的賦值實際上創建了一個全局對象name。
嚴格模式下，不通過new調用Person構造函數會出現錯誤，這是因為嚴格模式并沒有為全局對象設置this，this保持為undefined，而試圖給undefined添加屬性時都會出錯
構造函數允許給對象配置同樣的屬性，當構造函數并沒有消除代碼冗余，每個對象都有自己的sayName()方法，這意味著100個對象實例就有100個函數做相同的事情，只是使用的數據不同。如果所有的對象實例共享同一個方法會更有效率，該方法可以使用this.name來訪問對應的數據，這就需要用到原型對象。
4.2 原型對象
原型對象可以看做對象的基類，幾乎所有函數（除了一下內建函數）都有一個名為prototype的屬性，該屬性是一個原型對象用來創建新的對象實例。
所有創建的對象實例共享該原型對象，且這些對象實例可以訪問原型對象的屬性。例如，hasOwnProperty()方法被定義在泛用對象Object的原型對象中，但卻可以被任何對象當做自己的屬性訪問。
var book = {title: "the principles of object-oriented js"}
console.log("title" in book)
console.log(book.hasOwnProperty("title")) // true
console.log("hasOwnProperty" in book) // true
console.log(book.hasOwnProperty("hasOwnProperty")) // false
console.log(Object.prototype.hasOwnProperty("hasOwnProperty")) // true
即使book中沒有hasOwnProperty()方法的定義，但仍然可以通過book.hasOwnProperty()訪問該方法，這是因為該方法存在于Object.prototype中。
可以使用這樣一個方法來判斷一個屬性是否為原型屬性：
function hasPrototypeProperty(object, name){
return name in object && !object.hasOwnProperty(name)
}
4.2.1 [[Prototype]]屬性
一個對象實例通過內部屬性[[Prototype]]追蹤其原型對象，該 屬性時一個指向該實例使用的原型對象的指針。當你使用new創建一個新的對象時，構造函數的原型對象會被賦給該對象的[[Prototype]]屬性 (JS proto 探究.md )。你可以調用Object.getPropertyOf()方法讀取[[prototype]]屬性的值。
Object.prototype.__proto__ === null
var object={}
Object.getPrototypeOf(object) === Object.prototype // true
Object.prototype.isPrototypeOf(object) // true
任何一個泛用對象（字面量形式或者new Object()），其[[Prototype]]對象始終指向Object.prototype。也可以用isPrototypeOf()方法檢查某個對象是否是另一個對象的原型對象，該方法被包含在所有對象中。
Note:大部分Js引擎在所有對象上都支持一個__proto__的屬性，該屬性使你可以直接讀寫[[Prototype]]屬性。包括Firefox、Safari、Chrome、Node.js
在讀取一個對象的屬性時，Js引擎會首先在對象的自有屬性中查找屬性名字，如果找到則返回，如果沒有則Js會搜索[[Prototype]]中的對象，如果找到則返回，找不到則返回undefined。
var object = {}
console.log(object.toString()) // [object Object]
object.toString = function() {return "[object Custom]"}
console.log(object.toString()) // [object Custom]
delete object.toString
console.log(object.toString()) // [object Object]
delete object.toString
console.log(object.toString()) // [object Object]
上例可以看出，delete運算符只對只有屬性起作用，無法刪除一個對象的原型屬性。并且也不可以給一個對象的原型屬性賦值，對.toString的賦值只是在對象上創建了一個新的自有屬性，而不是改變原型屬性。
4.2.2 在構造函數中使用原型對象
原型對象的共享機制使得它們成為一次性為所有對象定義所有方法的理想手段，因為一個方法對所有的對象實例做相同的事，沒理由每個實例都要有一份自己的方法。將方法放在原型對象中并使用this方法當前實例是更有效的做法。
function Person(name) {this.name = name}
Person.prototype.sayName = function() {console.log(this.name)};
var person1 = new Person("Nicholas")
console.log(person1.name) // Nicholas
person1.sayName() // Nicholas
也可以在原型對象上存儲其他類型的數據，但是在存儲引用值時要注意，因為這些引用值會被多個實例共享，可能大家不希望一個實例能夠改變另一個實例的值。
function Person(name) {this.name = name}
Person.prototype.favorites = []
var person1 = new Person("Nicholas")
var person2 = new Person("Greg")
person1.favorites.push("pizza")
person2.favorites.push("quinoa")
console.log(person1.favorites) // ["pizza", "quinoa"]
console.log(person2.favorites) // ["pizza", "quinoa"]
favorites屬性被定義到原型對象上，意味著person1.favorites和person2.favorites指向同一個數組，你對任意Person對象的favorites插入的值都將成為原型對象上數組的元素。也可以使用字面量的形式替換原型對象：
function Person(name) {this.name=name}
Person.prototype= {
sayName: function() {console.log(this.name)},
toString: function(){return `[Person ${this.name} ]`}
}
雖然用這種字面量的形式定義原型非常簡潔，但是有個副作用需要注意。
var person1 = new Person("Nicholas")
console.log(person1 instanceof Person) // true
console.log(person1.constructor === Person) // false
console.log(person1.constructor === Object) // true
使用字面量形式改寫原型對象改寫了構造函數的屬性，因此現在指向Object而不是Person，這是因為原型對象具有個constructor屬性，這是其他對象實例所沒有的。當一個函數被創建時，其prototype屬性也被創建，且該原型對象的constructor屬性指向該函數自己，當使用字面量形式改寫原型對象Person.prototype時，其constructor屬性將被復寫為泛用對象Object。為了避免這一點，需要在改寫原型對象時手動重置其constructor屬性：
function Person(name) {this.name = name}
Person.prototype = {
constructor: Person, // 為了不忘記賦值，最好在第一個屬性就把constructor重置為自己
sayName() {console.log(this.name)},
toString() {return `[Person ${this.name} ]`}
}
var person1 = new Person("Nicholas")
console.log(person1 instanceof Person) // true
console.log(person1.constructor === Person) // true
console.log(person1.constructor === Object) // false
構造函數、原型對象、對象實例之間：對象實例和構造函數之間沒有直接聯系。不過對象實例和原型對象之間以及原型對象和構造函數之間都有直接聯系。
這樣的連接關系也意味著，如果打斷對象實例和原型對象之間的聯系，那么也將打斷對象實例及其構造函數之間的關系。
4.2.3 改變原型對象
給定類型的所有對象實例共享一個原型對象，所以可以一次性擴充所有對象實例。[[Prototype]]屬性只是包含了一個指向原型對象的指針，任何對原型對象的改變都將你可反映到所有引用它的對象實例上。這意味著給原型對象添加的新成員都可以立刻被所有已經存在的對象實例使用。
function Person(name) {this.name = name}
Person.prototype = {
constructor: Person,
sayName() {console.log(this.name)},
toString() {return `[Person ${this.name} ]`}
}
var person1 = new Person("Nicholas")
var person2 = new Person("Greg")
console.log("sayHi" in person1) // false
console.log("sayHi" in person2) // false
Person.prototype.sayHi = () => console.log("Hi")
person1.sayHi() // Hi
person2.sayHi() // Hi
當對一個對象使用Object.seal()或Object.freeze()封印和凍結對象的時候是在操作對象的自有屬性，無法添加封印對象的自有屬性和更改凍結對象的自有屬性，但是仍然可以通過在原型對象上添加屬性來擴展對象實例：
function Person(name) {this.name = name}
var person1 = new Person("Nicholas")
Object.freeze(person1)
Person.prototype.sayHi = function() {console.log("Hi")};
person1.sayHi() // Hi
其實，[[Prototype]]是實例對象的自有屬性，屬性本身person1.[[Prototype]]被凍結，但是指向的值Person.prototype并沒有凍結。
4.2.4 內建對象的原型對象
所有內建對象都有構造函數，因此也都有原型對象可以去改變，例如要在數組上添加一個新的方法只需要改變Array.prototype即可
Array.prototype.sum = function() {
return this.reduce((privious, current) => privious + current)
}
var numbers = [1, 2, 3, 4, 5, 6]
var result = numbers.sum()
console.log(result) // 21
sum()函數內部，在調用時this指向數組的對象實例numbers，因此this也可以調用該數組的其他方法，比如reduce()。
改變原始封裝類型的原型對象，就可以給這些原始值添加更多功能，比如：
String.prototype.capitalize = function() {
return this.charAt(0).toUpperCase() + this.substring(1)
}
var message = "hello world!"
console.log(message.capitalize()) // Hello world!
5. 繼承
5.1 原型對象鏈和Object.prototype
Js內建的繼承方法被稱為原型對象鏈，又稱為原型對象繼承。原型對象的屬性可以由對象實例訪問。實例對象集成了原型對象的屬性，因為原型對象也是一個對象，它也有自己的原型對象并繼承其屬性。這就是原型繼承鏈：對象繼承其原型對象，而原型對象繼承它的原型對象，以此類推。
所有的對象，包括自定義的對象都繼承自Object，除非另有指定。更確切的說，所有對象都繼承自Object.prototype，任何以字面量形式定義的對象，其[[Prototype]]的值都被設為Object.prototype，這意味著它繼承Object.prototype的屬性。
var book = {title: "a book"}
console.log(Object.getPrototypeOf(book) === Object.prototype) // true
5.1.1 繼承自Object.prototype的方法
前幾張用到的幾個方法都是定義在Object.prototype上的，因此可以被其他對象繼承：
| Methods |
Usage |
| hasOwnProperty() |
檢查是否存在一個給定名字的自有屬性 |
| propertyIsEnumerable() |
檢查一個自有屬性是否為可枚舉 |
| isPrototypeOf() |
檢查一個對象是否是另一個對象的原型對象 |
| valueOf() |
返回一個對象的值表達 |
| toString() |
返回一個對象的字符串表達 |
這幾種方法由繼承出現在所有的對象中，當你需要對象在Js中以一致的方式工作時，最后兩個尤為重要。
valueOf()
每當一個操作符被用于一個對象時就會調用valueOf()方法，其默認返回對象實例本身。原始封裝類型重寫了valueOf()以使得它對String返回一個字符串，對Boolean返回一個布爾，對Number返回一個數字；類似的，對Date對象的valueOf()返回一個epoch時間，單位是毫秒（正如Data.prototype.getTime()）。
var now = new Date // now.valueOf() === 1505108676169
var earlier = new Date(2010,1,1) // earlier.valueOf() === 1264953600000
console.log(now>earlier) // true
console.log(now-earlier) // 240155076169
now是一個代表當前時間的Date，而earlier是過去的時間，當使用操作符>時，兩個對象上都調用了valueOf()方法，你甚至可以用兩個Date相減來獲得它們在epoch時間上的差值。如果你的對象也要這樣使用操作符，你可以定義自己的valueOf()方法，定義的時候你并沒有改變操作符的行為，僅僅應了操作符默認行為所使用的值。
toString()
一旦valueOf()返回的是一個引用而不是原始值的時候，就會回退調用toString()方法。另外，當Js期望一個字符串時也會對原始值隱式調用toString()。例如當加號操作符的一邊是一個字符串時，另一邊就會被自動轉換成字符串，如果另一邊是一個原始值，會自動轉換成一個字符串表達（true => "true"），如果另一邊是一個引用值，則會調用valueOf()，如果其返回一個引用值，則調用toString()。
var book = {title: "a book"}
console.log("book = " + book) // "book = [object Object]"
因為book是一個對象，因此調用它的toString()方法，該方法繼承自Object.prototype，大部分Js引擎返回默認值[object Object]，如果對這個值不滿意可以復寫，為此類字符串提供包含跟多信息。
var book = {title: "a book",
toString(){return `[Book = ${this.title} ]`}}
console.log("book = " + book) // book = [Book = a book ]
5.1.2 修改Object.prototype
所有的對象都默認繼承自Object.prototype，所以改變它會影響到所有的對象，這是非常危險的。
如果給Obejct.prototype添加一個方法，它是可枚舉的，可以粗現在for-in循環中，一個空對象依然會輸出一個之前添加的屬性。盡量不要修改Object.prototype。
5.2 對象繼承
對象字面量形式會隱式指定Object.prototype為其[[Prototype]]，也可以用Object.create()方式顯示指定。Object.create()方法接受兩個參數：需要被設置為新對象[[Prototype]]的對象、屬性描述對象，格式如在Object.defineProperties()中使用的一樣（第三章）。
var book = {title: "a book"}
// ↑ 等價于 ↓
var book = Object.create(Object.prototype, {
title: {
configurable: true,
enumerable: true,
value: "a book",
writable: true
}
})
第一種寫法中字面量形式定義的對象自動繼承Object.prototype且其屬性默認設置為可配置、可寫、可枚舉。第二種寫法顯示使用Object.create()做了相同的操作，兩個book對象的行為完全一致。
var person = {
name: "Jack",
sayName: function(){
console.log(this.name);
}
}
var student = Object.create(person, {
name:{value: "Ljc"},
grade: {
value: "fourth year of university",
enumerable: true,
configurable: true,
writable: true
}
});
person.sayName(); // "Jack"
student.sayName(); // "Ljc"
console.log(person.hasOwnProperty("sayName")); // true
console.log(person.isPrototypeOf(student)); // true
console.log(student.hasOwnProperty("sayName")); // false
console.log("sayName" in student); // true
console.log(student.__proto__===person) // true
console.log(student.__proto__.__proto__===Object.prototype) // true
對象person2繼承自person1，也就集成了person1的name和sayName()，然而又通過重寫name屬性定義了一個自有屬性，隱藏并替代了原型對象中的同名屬性。所以person1.sayName()輸出Nicholas而person2.sayName()輸出Greg。
在訪問一個對象的時候，Js引擎會執行一個搜索過程，如果在對象實例上發現該屬性，該屬性值就會被使用，如果沒有發現則搜索[[Prototype]]，如果仍然沒有發現，則繼續搜索該原型對象的[[Prototype]]，知道繼承鏈末端，末端通常是一個Object.prototype，其[[prototype]]為null。這就是原型鏈。
當然也可以通過Object.create()創建[[Prototype]]為null的對象：var obj=Object.create(null)。該對象obj是一個沒有原型鏈的對象，這意味著toString()和valueOf等存在于Object原型上的方法都不存在于該對象上。
5.3 構造函數繼承
Js中的對象繼承也是構造函數繼承的基礎，第四章提到：幾乎所有的函數都有prototype屬性（通過Function.prototype.bind方法構造出來的函數是個例外），它可以被替換和修改。該prototype屬性被自動設置為一個繼承自Object.prototype的泛用對象，該對象有個自有屬性constructor。
// 構造函數
function YourConstructor() {}
// Js引擎在背后做的：
YourConstructor.prototype = Object.create(Object.prototype, {
constructor: {
configurable: true,
enumerable: true,
value: YourConstructor,
writable: true
}
})
console.log(YourConstructor.prototype.__proto__===Object.prototype) // true
你不需要做額外工作，Js引擎幫你把構造函數的prototype屬性設置為一個繼承自Object.prototype的對象，這意味著YourConstructor創建出來的任何對象都繼承自Object.prototype，YouConstructor是Object的子類。
由于prototype可寫，可以通過改寫它來改變原型鏈：
function Rectangle(length, width) {
this.length = length
this.width = width
}
Rectangle.prototype.getArea = function() {return this.length * this.width};
Rectangle.prototype.toString = function() {return `[ Rectangle ${this.length}x${this.width} ]`};
function Square(size) {
this.length = size
this.width = size
}
Square.prototype = new Rectangle()
Square.prototype.constructor = Square
Square.prototype.toString = function() {return `[ Square ${this.length}x${this.width} ]`}
var rect = new Rectangle(5, 10)
var squa = new Square(6)
console.log(rect instanceof Rectangle) // true
console.log(rect instanceof Square) // false
console.log(rect instanceof Object) // true
console.log(squa instanceof Rectangle) // true
console.log(squa instanceof Square) // true
console.log(squa instanceof Object) // true
MDN:instanceof 運算符可以用來判斷某個構造函數的 prototype 屬性是否存在另外一個要檢測對象的原型鏈上。
Square構造函數的prototype屬性被改寫為Rectagle的一個實例，此時不需要給Rectangle的調用提供參數，因為它們不需要被使用，而且如果提供了，那么所有的Square對象實例都會共享這樣的維度。如果用這種方式改寫原型鏈，需要確保構造函數不會再參數缺失時拋出錯誤（很多構造函數包含的初始化邏輯）且構造函數不會改變任何全局狀態。
// inherits from Rectangle
function Square(size){
this.length = size;
this.width = size;
}
Square.prototype = new Rectangle(); // 盡管是 Square.prototype 是指向了 Rectangle 的對象實例，即Square的實例對象也能訪問該實例的屬性（如果你提前聲明了該對象，且給該對象新增屬性）。
// Square.prototype = Rectangle.prototype; // 這種實現沒有上面這種好，因為Square.prototype 指向了 Rectangle.prototype，導致修改Square.prototype時，實際就是修改Rectangle.prototype。
console.log(Square.prototype.constructor); // 輸出 Rectangle 構造函數
Square.prototype.constructor = Square; // 重置回 Square 構造函數
console.log(Square.prototype.constructor); // 輸出 Square 構造函數
Square.prototype.toString = function(){
return "[Square " + this.length + "x" + this.width + "]";
}
var rect = new Rectangle(5, 10);
var square = new Square(6);
console.log(rect.getArea()); // 50
console.log(square.getArea()); // 36
console.log(rect.toString()); // "[Rectangle 5 * 10]", 但如果是Square.prototype = Rectangle.prototype，則這里會"[Square 5 * 10]"
console.log(square.toString()); // "[Square 6 * 6]"
console.log(square instanceof Square); // true
console.log(square instanceof Rectangle); // true
console.log(square instanceof Object); // true
Square.prototype 并不真的需要被改成為一個 Rectangle 對象。事實上，是 Square.prototype 需要指向 Rectangle.prototype 使得繼承得以實現。這意味著可以用 Object.create() 簡化例子。
// inherits from Rectangle
function Square(size){
this.length = size;
this.width = size;
}
Square.prototype= Object.create(Rectangle.prototype, {
constructor: {
configurable: true,
enumerable: true,
value: Square,
writable: true
}
})
在對原型對象添加屬性前要確保你已經改寫了原型對象，否則在改寫時會丟失之前添加的方法（因為繼承是將被繼承對象賦值給需要繼承的原型對象，相當于重寫了需要繼承的原型對象）。
5.4 構造函數竊取
由于JavaScript中的繼承是通過原型對象鏈來實現的，因此不需要調用對象的父類的構造函數。如果確實需要在子類構造函數中調用父類構造函數，那就可以在子類的構造函數中利用 call、apply方法調用父類的構造函數。
function Rectangle(length, width) {
this.length = length
this.width = width
}
Rectangle.prototype.getArea = function() {return this.length * this.width};
Rectangle.prototype.toString = function() {return `[ Rectangle ${this.length}x${this.width} ]`};
function Square(size) {Rectangle.call(this, size, size)}
Square.prototype = Object.create(Rectangle.prototype, {
constructor: {
value: Square,
enumerable: true,
configurable: true,
writable: true
}
})
Square.prototype.toString = function() {return `[ Square ${this.length}x${this.width} ]`}
var rect = new Rectangle(5, 10)
var squa = new Square(6)
console.log(rect.getArea())
console.log(rect.toString())
console.log(squa.getArea())
console.log(squa.toString())
一般來說，需要修改 prototype 來繼承方法并用構造函數竊取來設置屬性，由于這種做法模仿了那些基于類的語言的類繼承，所以這通常被稱為偽類繼承。
5.5 訪問父類方法
其實也是通過指定 call 或 apply 的子對象調用父類方法。
6. 對象模式
可以使用繼承或者混入等其他技術令對象間行為共享，也可以利用Js高級技巧阻止對象結構被改變。
6.1 私有成員和特權成員
6.1.1 模塊模式
模塊模式是一種用于創建擁有私有數據的單件對象的模式。
基本做法是使用立即調用函數表達式（IIFE）來返回一個對象。原理是利用閉包。
var yourObj = (function(){
// private data variables
return {
// public methods and properties
}
}());
模塊模式還有一個變種叫暴露模塊模式，它將所有的變量和方法都放在 IIFE 的頭部，然后將它們設置到需要被返回的對象上。
// 一般寫法
var yourObj = (function(){
var age = 25;
return {
name: "Ljc",
getAge: function(){
return age
}
}
}());
// 暴露模塊模式，保證所有變量和函數聲明都在同一個地方
var yourObj = (function(){
var age = 25; // 私有變量，外部無法訪問
function getAge(){
return age
};
return {
name: "Ljc", // 公共變量外部可以訪問
getAge: getAge // 外部可以訪問的對象
}
}());
6.1.2 構造函數的私有成員
模塊模式在定義單個對象的私有屬性十分有效，但對于那些同樣需要私有屬性的自定義類型呢？你可以在構造函數中使用類似的模式來創建每個實例的私有數據。
function Person(name){
// define a variable only accessible inside of the Person constructor
var age = 22;
this.name = name;
this.getAge = function(){return age;};
this.growOlder = function(){age++;}
}
var person = new Person("Ljc");
console.log(person.age); // undefined
person.age = 100;
console.log(person.getAge()); // 22
person.growOlder();
console.log(person.getAge()); // 23
構造函數在被new的時候創建了一個本地作用于并返回this對象。這里有個問題：如果你需要對象實例擁有私有數據，就不能將相應方法放在 prototype上。
如果你需要所有實例共享私有數據（就好像它被定義在原型對象里那樣），則可結合模塊模式和構造函數，如下：
var Person = (function(){
var age = 22;
function InnerPerson(name){this.name = name;}
InnerPerson.prototype.getAge = function(){return age;}
InnerPerson.prototype.growOlder = function(){age++;};
return InnerPerson;
}());
var person1 = new Person("Nicholash");
var person2 = new Person("Greg");
console.log(person1.name); // "Nicholash"
console.log(person1.getAge()); // 22
console.log(person2.name); // "Greg"
console.log(person2.getAge()); // 22
person1.growOlder();
console.log(person1.getAge()); // 23
console.log(person2.getAge()); // 23
6.2 混入
這是一種偽繼承。一個對象在不改變原型對象鏈的情況下得到了另外一個對象的屬性被稱為“混入”。因此，和繼承不同，混入讓你在創建對象后無法檢查屬性來源。
function mixin(receiver, supplier){
for(var property in supplier){
if(supplier.hasOwnProperty(property)){
receiver[property] = supplier[property];
}
}
}
這是淺拷貝，如果屬性的值是一個引用，那么兩者將指向同一個對象。
要注意一件事，使用這種方式，supplier的訪問器屬性會被復制為receiver的數據屬性。
function mixin(reciver, supplier) {
if (Object.getOwnPropertyDescriptor) { // 檢查是否支持es5
Object.keys(supplier).forEach(property => {
var descriptor = Object.getOwnPropertyDescriptor(supplier, property)
Object.defineProperty(reciver, property, descriptor)
})
} else {
for (var property in supplier) { // 否則使用淺復制
if (supplier.hasOwnProperty(property)) {
reciver[property] = supplier[property]
}
}
}
}
6.3 作用域安全的構造函數
構造函數也是函數，所以不用 new 也能調用它們來改變 this 的值。在非嚴格模式下， this 被強制指向全局對象。而在嚴格模式下，構造函數會拋出一個錯誤（因為嚴格模式下沒有為全局對象設置 this，this 保持為 undefined）。
而很多內建構造函數，例如 Array、RegExp 不需要 new 也能正常工作，這是因為它們被設計為作用域安全的構造函數。
當用 new 調用一個函數時，this 指向的新創建的對象已經屬于該構造函數所代表的自定義類型。因此，可在函數內用 instanceof 檢查自己是否被 new 調用。
function Person(name){
if(this instanceof Person){
// called with "new"
}else{
// called without "new"
}
}
具體案例：
function Person(name){
if(this instanceof Person){
this.name = name;
}else{
return new Person(name);
}
}
PS：歡迎大家關注我的公眾號【前端下午茶】，一起加油吧~
另外可以加入「前端下午茶交流群」微信群，長按識別下面二維碼即可加我好友，備注加群，我拉你入群～
