1.創(chuàng)建自定義對象的最簡單方式就是**創(chuàng)建一個Object()的實例**，然后再為它添加屬性和方法；隨后流行**使用對象字面量創(chuàng)建對象**。
2.ECMAScript的屬性(property)由內(nèi)部才能用的特性(attribute)來描述。內(nèi)部特性無法在JavaScript中直接訪問。為了表示特性是內(nèi)部值，該規(guī)范把它們放在了兩對方括號中。
3.ECMAScrip有兩種屬性：數(shù)據(jù)屬性和訪問器屬性。
4.數(shù)據(jù)屬性有四個描述其行為的特性：
**[[Configurable]]**：表示能否通過delete刪除屬性從而重新定義屬性，能否修改屬性的特性，或者能否把屬性修改為訪問器屬性。這個特性的默認值為true。
**[[Enumearble]]**：表示能否通過for-in循環(huán)返回屬性。這個特性默認值為true。
**[[Writable]]**：表示能否修改屬性的值。這個特性的默認值為true。
**[[Value]]**：包含這個屬性的數(shù)據(jù)值。讀取屬性值的時候，從這個位置讀；寫入屬性值的時候，把新值保存在這個位置。這個特性的默認值為undefined。
5.要修改屬性默認的特性，必須使用ECMAScript5的Object.defineProperty()方法。這個方法接收三個參數(shù)：屬性所在的對象、屬性的名字和一個描述符對象。其中描述符對象的屬性必須是configurable、enumerable、writable、value。例：
~~~
var person = {};
Object.defineProperty(person,’name’,{
writable:false,
value:’Nicholas’
});
~~~
6.一旦把屬性定義為不可配置的，就不能再把它變回可配置了，此時再調(diào)用Object.defineProperty()方法修改除writable之外的特性，都會導致錯誤。在調(diào)用Obejct.defineProperty()方法時，如果不指定，configurable、writable、enumerable特性的默認值都為false。
7.訪問器不包含數(shù)據(jù)，包含一對getter和setter函數(shù)（不過這兩個函數(shù)都不是必須的）。在讀取訪問器屬性時，會調(diào)用getter函數(shù)，這個函數(shù)負責返回有效的值；在寫入訪問器屬性時，會調(diào)用setter函數(shù)并傳入新值，這個函數(shù)負責決定如何處理數(shù)據(jù)。訪問器屬性有如下4個特性：
**[[Configurable]]**：表示能否通過delete刪除屬性從而重新定義屬性，能否修改屬性的特性，或者能否把屬性修改為數(shù)據(jù)屬性。這個特性的默認值為true。
**[[Enumearble]]**：表示能否通過for-in循環(huán)返回屬性。這個特性默認值為true。
**[[Get]]**：在讀取屬性時調(diào)用的函數(shù)。這個特性的默認值為undefined。
**[[Set]]**：在寫入屬性時調(diào)用的函數(shù)。這個特性的默認值為undefined。
8.訪問器屬性不能直接定義，必須使用***Object.defineProperty()***來定義。例：
~~~
var book = {
_year:2004,
edition:1
};
Object.defineProperty(book,’year’,{
get:function(){
return this._year;
},
set:function(newValue){
if (newValue>2004) {
this._year = newValue;
this.edition += newValue-2004;
}
}
});
book.year = 2005;
alert(book.edition); //2
~~~
以上代碼創(chuàng)建了一個book對象，并給它定義了兩個默認屬性。_year和edition。**_year前面的下劃線是一種常用的記號，用于表示只能通過對象方法訪問的屬性。**在這個函數(shù)里，把year屬性修改為2005會導致_year變成2005，而edition變?yōu)?。**這是使用訪問器屬性的常見方式，即設置一個屬性的值會導致其他屬性發(fā)生變化。**
9.***Object.defineProperties()***方法可以通過描述符一次定義多個屬性。這個方法接收兩個對象參數(shù)：第一個對象是要添加和修改其屬性的對象，第二個對象的屬性與第一個對象中要添加或修改的屬性一一對應。例：
~~~
var book = {};
Object.defineProperties(book,{
_year: {
value:2004
},
edition:{
value:1
},
year:{
get:function(){
return this._year;
},
set:function(newValue){
if (newValue>2004) {
this._year = newValue;
this.edition += newValue-2004;
}
}
}
});
~~~
10.***Object.getOwnPropertyDescriptor()***方法，可以取得給定屬性的描述符。這個方法接收兩個參數(shù)：屬性所在的對象和要讀取其描述符的屬性名稱。返回值是一個對象，如果是訪問其屬性，這個對象的屬性有configurable、enumerable、get和set；如果是數(shù)據(jù)屬性，這個對象的屬性有configurable、enumerable、writable和value。這個方法只能用于實例屬性，要取得原型屬性的描述符，必須直接在原型對象上調(diào)用這個方法。
~~~
var descriptor = Object.getOwnpropertyDescriptor(book,’_year’);
alert(descriptor.value) //2005
alert(descriptor.configurable) //false
alert(descriptor.get) //undefined
~~~
11.**工廠模式在JavaScript中是指用函數(shù)來封裝以特定接口創(chuàng)建對象的細節(jié)**。這種模式抽象了創(chuàng)建具體對象的過程。例：
~~~
function createPerson(name,age,job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
alert(this.name);
};
return o;
}
~~~
**工廠模式雖然解決了創(chuàng)建多個相似對象的問題，但卻沒有解決對象識別的問題（即怎么知道一個對象的類型）。**
12.**構(gòu)造函數(shù)模式**
**通過創(chuàng)建自定義的構(gòu)造函數(shù)，從而定義自定義對象類型的屬性和方法。**
~~~
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.setName = function(){
alert(this.name)
};
}
~~~
Person()函數(shù)與createPerson()函數(shù)之間的不同之處在于：
-沒有顯式地創(chuàng)建對象；
-直接將屬性和方法賦給了this對象；
-沒有return語句；
按照慣例，***構(gòu)造函數(shù)始終都應該以一個大寫字母開頭，而非構(gòu)造函數(shù)則應該以一個小寫字母開頭。***這個做法借鑒自其他OO語言，主要為了區(qū)別于ECMAScript中的其他函數(shù)；因為構(gòu)造函數(shù)本身也是函數(shù)，只不過可以用來創(chuàng)建對象而已。
要創(chuàng)建Person對象的新實例，必須使用new 操作符。以這種方式調(diào)用構(gòu)造函數(shù)實際上會經(jīng)歷以下四個步驟：
* **創(chuàng)建一個新對象；**
* **將構(gòu)造函數(shù)的作用域賦給新對象（因此this就指向了這個新對象）**
* **執(zhí)行構(gòu)造函數(shù)中的代碼（為這個新對象添加屬性）；**
* **返回新對象**。
創(chuàng)建自定義的構(gòu)造函數(shù)意味著將來可以將它的實例標識為一種特定的類型。
任何函數(shù)，只要通過new操作符來調(diào)用，那它就可以作為構(gòu)造函數(shù)；而任何函數(shù)，如果不通過new操作符來調(diào)用，那它跟普通函數(shù)沒有什么區(qū)別。**當一個原意用作構(gòu)造函數(shù)的函數(shù)不通過new操作符調(diào)用，那函數(shù)體內(nèi)的this對象就指向全局作用域window。**當然，可以通過call()或者apply()在某個特殊對象的作用域中調(diào)用。例：
~~~
var o = new Object();
Person.call(0,’Ken’,28,’frontend’);
o.sayName(); //Ken
~~~
構(gòu)造函數(shù)的主要問題在于，每個方法都要在每個實例上重新創(chuàng)建一遍?？梢酝ㄟ^把函數(shù)定義轉(zhuǎn)移到構(gòu)造函數(shù)外面來解決這個問題：
~~~
function sayName() {
alert(this.name);
}
~~~
但這樣的做法又帶來了新問題，全局作用域中定義的函數(shù)實際上只能被某個對象調(diào)用，這讓全局作用域有點名不副實。而更讓人無法接受的是：如果對象需要定義很多方法，那么就要定義很多個全局函數(shù)，于是我們這個自定義的引用類型就絲毫沒有封裝性可言。
13.**原型模式**
每個創(chuàng)建的**函數(shù)**都有一個prototype屬性，這個屬性是一個指針，指向一個對象，而這個對象的用途是包含可以由特定類型的所有實例共享的屬性和方法。prototype就是通過調(diào)用構(gòu)造函數(shù)而創(chuàng)建的那個對象實例的原型對象。使用原型對象的好處是可以就讓所有對象實例共享它所包含的屬性和方法。例：
~~~
function Person(){
}
Person.prototype.name = ‘ken’;
Person.prototype.age = 28;
Person.prototype.job = ‘frontend’;
Person.prototype.sayName = function(){
alert(this.name);
};
var person1 = new Person();
var person2 = new Person();
alert(person1.sayName == person2.sayName); //true （不加括號，否則對比的是運行值）
~~~
關于原型對象的深入理解可以查看P148.
14.無論什么時候，只要創(chuàng)建了一個新函數(shù)，就會根據(jù)一組特定的規(guī)則為該函數(shù)創(chuàng)建一個prototype屬性，這個屬性指向函數(shù)的原型對象。
15.在默認情況下，所有原型對象都會自動獲得一個constructor（構(gòu)造函數(shù)）屬性，這個屬性指向prototype屬性所在函數(shù)的指針。例如Person.prototype.constructor指向Person。
16.當調(diào)用構(gòu)造函數(shù)創(chuàng)建一個新實例后，該實例的內(nèi)部將包含一個[[prototype]]指針（主流瀏覽器中的_proto_屬性）**。要明確的重要一點是，這個連接存在于實例與原型對象之間，而不是存在于實例與構(gòu)造函數(shù)之間。**
17.**雖然在所有實現(xiàn)中都無法訪問[[prototype]]，但可以通過isPrototypeOf()方法來確定對象之間是否存在這種關系。**
~~~
alert(Person.prototype.isPrototypeOf(person1)); //true
alert(Person.prototype.isPrototypeOf(person2)); //true
~~~
18.**Ojbect.getPrototypeOf()方法返回[[prototype]]的值。**
~~~
alert(Object.getPrototypeOf(person1)) //Person.prototype
alert(Object.getPrototypeOf(person1).name) //ken
~~~
19.雖然可以通過對象實例訪問保存在原型中的值，但卻不能通過對象實例重寫原型中的值。如果我們在實例中添加了一個屬性，而該屬性與實例原型中的一個屬性同名，那我們就在實例中創(chuàng)建該屬性，該屬性將會屏蔽原型中的那個屬性，但不會修改那個屬性。不過，使用delete操作符則可以完全刪除實例屬性，從而讓我們能夠重新訪問原型中的屬性。
~~~
var person1 = new Person();
person1.name = 'jason';
delete person1.name;
alert(person1.name); //ken
~~~
20.單獨使用in操作符，會在通過對象能夠訪問給定屬性時返回true，無論該屬性存在于實例中還是原型中。
`alert('name' in person1); //true;`
使用for-in循環(huán)時，返回的是所有能夠通過對象訪問的，可枚舉的屬性，其中既包含存在于實例中的屬性，也包括存在原型中的屬性。屏蔽了原型中不可枚舉屬性的實例屬性也會在for-in循環(huán)中返回，因為根據(jù)規(guī)定，所有開發(fā)人員定義的屬性都是可枚舉的（除了IE8及更早版本）。
要取得對象上所有**可枚舉的實例屬性**，可以使用ECMAScript5中的***Object.keys()***方法。這個方法接收一個對象作為參數(shù)，返回一個包含所有可枚舉屬性的字符串數(shù)組。
如果想要得到所有實例屬性，無論它是否可枚舉，都可以使用**Object.getOwnPropertyNames()**。
總結(jié)：
for-in 實例+原型、可枚舉；
Object.keys() 實例、可枚舉；
Object.getOwnPropertyNames() 實例、可枚舉+不可枚舉
21.更簡單的原型語法：
~~~
function Person(){
}
Person.prototype = {
name:'Ken',
age:28,
job:'FrontEnd Engineer',
sayName:function(){
alert(this.name);
}
};
~~~
**使用這樣的語法創(chuàng)建原型對象，constructor屬性不再指向Person了。前面曾經(jīng)介紹過，每創(chuàng)建一個函數(shù)，就會同時創(chuàng)建他的prototype對象。在這里使用的語法，本質(zhì)上完全重寫了默認的prototype對象，因此，constructor屬性也就變成了新對象的constructor屬性(指向Object構(gòu)造函數(shù))，不再指向Person函數(shù)。此時，盡管instanceof操作符還能返回正確的結(jié)果，但通過constructor已經(jīng)無法確立對象的類型了。**
**如果constructor的值真的很重要，那么在使用上面的語法重寫原型對象時，可以手動將construtor的屬性值設為Person。注意，以這種方式重設constructor屬性會導致他的[[Enumerable]]特性被置為true?？梢酝ㄟ^Object.defineProperty()方法將屬性置為默認的不可枚舉：**
~~~
Object.defineProperty(Person.prototype,'constructor',{
enumerable: false,
value: Person
});
~~~
22.原型的動態(tài)性
由于在原型中查找值的過程是一次搜索，因此我們對原型對象所做的任何修改都能夠立即從實例上反映出來--即使是先創(chuàng)建了實例后修改原型也照樣如此。
盡管可以隨時為原型添加屬性和方法，并且修改能夠立即在所有對象實例中反映出來，但**如果是重寫整個原型對象，那么情況就不一樣了。我們知道，調(diào)用構(gòu)造函數(shù)時會為實例添加一個指向最初原型的[[Prototype]]指針，而把原型修改為另一個對象就等于切斷了構(gòu)造函數(shù)與最初原型之間的聯(lián)系。**
23.不推薦在產(chǎn)品化的程序中修改原生對象的原型。
24.將構(gòu)造函數(shù)模式用于定義實例屬性，而原型模式用于定義方法和共享的屬性，這是目前在ECMAScript中使用最廣泛、認同度最高的一種創(chuàng)建自定義類型的方法。
~~~
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.friends = ['wesley','fox'];
}
Person.prototype = {
constructor:Person,
sayName:function(){
alert(this.name)
}
}
~~~
25.**動態(tài)原型模式**解決了構(gòu)造函數(shù)與原型分別獨立、沒有封裝在一起的問題。
~~~
function Person(name,age,job){
this.name = name;
this.age = age;
this.job = job;
this.friends = ['wesley','fox'];
if (typeof this.sayName !== 'function') {
Person.prototype.sayName = function(){
alert(this.name)
}
}
}
~~~
26.**寄生構(gòu)造函數(shù)模式**解決了這樣一個場景下的問題：假設想創(chuàng)建一個具有額外方法的特殊數(shù)組，又不能直接修改Array構(gòu)造函數(shù)，就可以使用這個模式。**除了使用new操作符并把使用的包裝函數(shù)叫做構(gòu)造函數(shù)之外，這個模式跟工廠模式其實是一模一樣的**。
~~~
function SpecialArray(){
var values = new Array();
values.push.apply(values,arguments); //此處使用apply是因為apply可以方便地把arguments添加到values數(shù)組。
values.toPipeString = function(){
return this.join('|');
}
return values;
}
var colors = new SpecialArray('red','blue','green');
alert(colors.toPipeString()); //'red|blue|green'
~~~
關于寄生構(gòu)造函數(shù)模式，有一點需要說明：首先，返回的對象與構(gòu)造函數(shù)或者與構(gòu)造函數(shù)的原型屬性之間沒有關系；也就是說，構(gòu)造函數(shù)返回的對象與構(gòu)造函數(shù)外部創(chuàng)建的對象沒什么不同。為此，**不能依賴instanceof操作符來確定對象類型**。由于存在上述問題，我們建議在在可以使用其他模式的情況下，不要使用這種模式。
~~~
alert(SpecialArray.prototype.isPrototypeOf(colors)); //false
alert(colors instanceof SpecialArray); //false
~~~
27.所謂**穩(wěn)妥對象**，指的是沒有公共屬性，而且其方法也不引用this的對象。穩(wěn)妥對象最適合在一些安全的環(huán)境中（這些環(huán)境會禁止使用this和new），或者防止數(shù)據(jù)被其他應用程序改動時使用。**穩(wěn)妥構(gòu)造函數(shù)模式遵循與寄生構(gòu)造函數(shù)模式類似的模式，但有兩點不同：一是新創(chuàng)建對象實例方法不引用this；二是不使用new操作符調(diào)用構(gòu)造函數(shù)。**
~~~
function Person(name,age,job){
//var name = name，age = age,job = job;
var o = new Object();
o.sayName = function(){
alert(name);
};
return o;
}
var friend = Person('ken','28','FrontEnd Engineer');
friend.sayName(); //ken
~~~
這樣，變量friend中保存的是一個穩(wěn)妥對象，而除了調(diào)用sayName()方法外，沒有別的方式可以訪問其數(shù)據(jù)成員。即使有其他代碼會給這個對象添加方法和數(shù)據(jù)成員，但也不可能有別的辦法訪問傳入到構(gòu)造函數(shù)中的原始數(shù)據(jù)。與寄生構(gòu)造函數(shù)模式類似，使用穩(wěn)妥構(gòu)造函數(shù)模式創(chuàng)建的對象與構(gòu)造函數(shù)之間也沒有什么關系型，因此instanceof操作符對這種對象也沒有意義。
28.ECMAScript只支持實現(xiàn)繼承，而且其實現(xiàn)繼承主要是依靠原型鏈來實現(xiàn)的。**原型鏈的基本思想是讓一個引用類型繼承另一個引用類型屬性和方法**。***具體的實現(xiàn)方法就是讓一個引用類型的原型等于另一個類型的實例***。
~~~
function SuperType(){
this.property = true;
}
SuperType.property.getSuperValue = function(){
return this.property;
}
function SubType(){
this.subproperty = false;
}
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function(){
return this.subproperty;
}
var instance = new SubType();
alert(instance.getSuperValue) //true
~~~
要注意，此時instance.constructor現(xiàn)在指向的是SuperType，這是因為SubType的原型指向了另一個對象--SuperType的原型，而這個原型對象的constructor屬性指向的是SuperType。
29.由于原型鏈的關系，我們可以說instance是Object、SuperType、SubType中任何一個類型的實例。通過兩種方式來確定原型與實例之間的關系。第一種方式是使用instanceof操作符；第二種方式是使用isPrototypeOf()方法。
`alert(SubType.prototype.isPrototypeOf(instance)); //true;`
30.原型鏈的主要問題：第一，包含引用類型值的原型屬性會被所有實例共享。第二，在創(chuàng)建子類型的實例時，沒有辦法在不影響那個所有對象實例的情況下，給超類型的構(gòu)造函數(shù)傳遞參數(shù)。
31.**借用構(gòu)造函數(shù)（經(jīng)典繼承）**的基本思想相當簡單，即在子類型構(gòu)造函數(shù)的內(nèi)部調(diào)用超類型構(gòu)造函數(shù)。
~~~
function SuperType(){
this.colors = ['red','yellow','blue'];
}
function SubType(){
SuperType.call(this);
}
~~~
通過使用call()或者apply()方法，我們實際上是在（未來將要）創(chuàng)建的SubType實例的環(huán)境下調(diào)用了SuperType構(gòu)造函數(shù)。這樣一來，就會在新SubType()對象上執(zhí)行SuperType()函數(shù)中定義的所有對象初始化代碼。結(jié)果，SubType的每個實例就都會具有自己的colors屬性的副本。
相對于原型鏈而言，借用構(gòu)造函數(shù)有一個很大的優(yōu)勢，即可以在子類型構(gòu)造函數(shù)中向超類型構(gòu)造函數(shù)傳遞參數(shù)。
~~~
function SuperType(name){
this.name = name;
}
function SubType(){
SuperType.call(this,'ken');
this.age = 28；
}
~~~
如果僅僅是借用構(gòu)造函數(shù)，那么也將無法避免構(gòu)造函數(shù)模式存在的問題--方法都在構(gòu)造函數(shù)中定義，因此函數(shù)復用就無從談起了。而且，在超類型的原型中定義的方法（使用prototype定義的），對于子類型而言也是不可見的，結(jié)果所有類型都只能使用構(gòu)造函數(shù)模式。
32.**組合繼承（偽經(jīng)典模式）**其背后的思路是使用原型鏈實現(xiàn)對原型屬性和方法的繼承，而通過借用構(gòu)造函數(shù)來實現(xiàn)對實例屬性的繼承。這樣，既在原型上定義方法實現(xiàn)了函數(shù)復用，又能夠保證每個實例都有自己的屬性。
~~~
function SuperType(name){
this.name = name;
this.colors = ['red','blue'.'green];
}
SuperType.prototype.sayName = function(){
alert(this.name);
};
function SubType(name,age) {
//繼承屬性
SuperType.call(this,name);
this.age = age;
}
//繼承方法
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
alert(this.age);
}
var instance1 = new SubType('ken',28);
instance1.colors.push('black);
alert(instance1.colors); //'red,blue,green,black'
instance1.sayName(); //'ken'
instance1.sayAge(); //28
var instance2 = new SubType('Greg',27);
alert(instance2.colors); //'red,blue,green'
instance2.sayName(); //'Greg'
instance2.sayAge(); //27
~~~
組合繼承避免了原型鏈和借用構(gòu)造函數(shù)的缺陷，融合了他們的優(yōu)點，成為JavaScript中最常用的繼承模式。而且，instanceof和isPrototypeOf()也能夠用于識別鯽魚組合繼承創(chuàng)建的對象。
33.**原型式繼承**沒有嚴格意義上的使用構(gòu)造函數(shù)，它是借助原型可以基于已有的對象創(chuàng)建新對象，同時還不必因此創(chuàng)建自定義類型。
~~~
function object(o){
function F(){}
F.prototype = o;
return new F();
}
~~~
在object()函數(shù)內(nèi)部，先創(chuàng)建了一個臨時性的構(gòu)造函數(shù)，然后將傳入的對象作為這個構(gòu)造函數(shù)的原型，最后返回這個臨時類型的新實例。從本質(zhì)上講，object()對傳入其中的對象執(zhí)行了一次淺復制。例：
~~~
var person = {
name: 'Nicholas',
friends: ['wesley','fox']
};
var anotherPerson = object(person);
anotherPerson.name = 'Greg';
anotherPerson.friends.push('Rob');
var yetAnotherPerson = object(person);
yetAnotherPerson.name = 'Linda';
yetAnotherPerson.friends.push('Barbie');
alert(person.friends); //'wesley,fox,Rob,Barbie'
~~~
ES5通過新增Object.creat()方法規(guī)范了原型式繼承。這個方法接收兩個參數(shù)：一個用作新對象原型的對象和（可選的）一個為新對象定義額外屬性的對象。
~~~
var person = {
name: 'Nicholas',
friends: ['wesley','fox']
};
var anotherPerson = Object.create(person, {
name：{
value: 'Greg'
}
});
~~~
在沒有必要興師動眾地創(chuàng)建構(gòu)造函數(shù)，而只是想讓一個對象與另個對象保持類似的情況下，原型式繼承是完全可以勝任的。不過別忘了，包含引用類型值的屬性始終都會共享相應的值，就像使用原型模式一樣。
34.**寄生式繼承**是與原型式繼承密寫相關的一種思路，即創(chuàng)建一個僅用于封裝繼承過程的函數(shù)，該函數(shù)在內(nèi)部以某種方式來增強對象，最后再像真的是它做了所有工作一樣返回對象。
~~~
function createAnother(original) {
var clone = object(original);
clone.sayHi = function(){
alert('hi');
};
return clone;
}
~~~
這樣創(chuàng)建的新對象不僅具有original的所有屬性和方法，而且還有自己的sayHi()方法。在主要考慮對象而不是自定義類型和構(gòu)造函數(shù)的情況下，寄生式繼承也是一種有用的模式。
35.**寄生組合式繼承**
所謂寄生組合式繼承，即通過借用構(gòu)造函數(shù)來繼承屬性，通過原型鏈的混成形式來繼承方法。其背后的思路是**：不必為了指定子類型的原型調(diào)用超類型的構(gòu)造函數(shù)，我們所需要的無非就是超類型原型的一個副本而已。**本質(zhì)上，就是使用寄生式繼承來繼承超類型的原型，然后再將結(jié)果指定給子類型的原型。
~~~
function inheritPrototype(subType,SuperType){
var prototype = Object(subType.prototype);
prototype.constructor = subType;
subType.prototype = prototype;
}
~~~
~~~
function SuperType(name){
this.name = name;
this.colors = ['red','blue'.'green];
}
SuperType.prototype.sayName = function(){
alert(this.name);
};
function SubType(name,age) {
//繼承屬性
SuperType.call(this,name);
this.age = age;
}
//繼承方法
inheritPrototype(subType,SuperType);
SubType.prototype.sayAge = function(){
alert(this.age);
}
~~~
**寄生組合式繼承與組合繼承的區(qū)別在于，前者不將超類型中的實例屬性繼承為子類型的原型屬性。**
AI寫作智能體 自主規(guī)劃任務，支持聯(lián)網(wǎng)查詢和網(wǎng)頁讀取，多模態(tài)高效創(chuàng)作各類分析報告、商業(yè)計劃、營銷方案、教學內(nèi)容等。
![]()
廣告