JavaScript高级程序设计--学习笔记（第六章）
文章目录
- 第六章 面向对象的程序设计
- 1. 理解对象
- 1.1 属性类型
- 1.2 定义多个属性
- 1.3 读取属性的特性
- 2. 创建对象
- 2.1 工厂模式
- 2.2 构造函数模式
- 2.3 原型模式
- 2.4 组合使用构造函数模式和原型模式
- 2.5 动态原型模式
- 2.6 寄生构造函数
- 2.7 稳妥构造函数模式
- 3. 继承
- 3.1 原型链
- 3.2 借助构造函数
- 3.3 组合继承
- 3.4 原型式继承
- 3.5 寄生式继承
- 3.6 寄生组合式继承
第六章 面向对象的程序设计
1. 理解对象
1.1 属性类型
ECMAScript 中有两种属性：数据属性和访问器属性
1).数据属性
数据属性包含一个数据值的位置。在这个位置可以读取和写入值。数据属性有4个描述其行为的特性：
Configurable - 表示能否通过delete删除属性从而重新定义属性，能否修改属性的特征，或者能否把属性修改为访问器属性，默认值为true
Enumerable - 示能否通过for-in循环返回属性，默认值为true
Writeable - 能否写入
Value - 包含这个属性的数据值，写入属性的时候把值存在这，默认值为 undefined
Object.defineProperty() - 修改默认特性
如：
var person = {}Object.defineProperty(person, "name", {writable: false,value: "limy"})console.log(person.name); // limyperson.name = "limy1"console.log(person.name); // limy
2).访问器属性
Configurable - 表示能否通过delete删除属性从而重新定义属性，能否修改属性的特征，或者能否把属性修改为访问器属性，默认值为true；
Enumerable - 示能否通过for-in循环返回属性，默认值为true；
Get - 读取属性时调用的函数；
Set - 写入属性时调用的函数；
访问器属性不能直接定义，需要通过Object.defineProperty()
如：
var book = {_year: 2018,edition: 1
};Object.defineProperty(book,"year", {get: function() {return this._year},set: function(newValue) {if(newValue > 2018) {this._year = newValue;this.edition += newValue - 2018;}}
});book.year = 2019;
alert(book.edition); // 2
1.2 定义多个属性
ECMAScript 5 定义了一个 Object.defineProperties()方法。利用这个方法可以通过描述符一次定义多个属性。
这个方法接收两个对象参数：第一对象是要添加和修改其属性的对象，第二个对象的属性与第一个对象中要添加或修改的属性一一对应。
支持 Object.defineProperties()方法的浏览器有 IE9+、Firefox 4+、Safari 5+、Opera 12+和Chrome。
1.3 读取属性的特性
使用 ECMAScript 5 的 Object.getOwnPropertyDescriptor()方法，可以取得给定属性的描述符。
这个方法接收两个参数：属性所在的对象和要读取其描述符的属性名称。返回值是一个对象，如果是访问器属性，这个对象的属性有 configurable、enumerable、get 和 set；如果是数据属性，这个对象的属性有 configurable、enumerable、writable 和 value。
在 JavaScript 中，可以针对任何对象——包括 DOM 和 BOM 对象，使用 Object.getOwnPropertyDescriptor()方法。支持这个方法的浏览器有 IE9+、Firefox 4+、Safari 5+、Opera 12+和 Chrome
2. 创建对象
2.1 工厂模式
工厂模式是软件工程领域一种广为人知的设计模式，这种模式抽象了创建具体对象的过程。即创建了一种函数，把对象放到函数里，用函数封装创建对象的细节。
工厂模式解决了代码复用（即创建多个类似对象）的问题，却没有解决对象识别的问题。创建的所有对象都是Object 类型。为了解决这一问题，又有了构造函数模式。
2.2 构造函数模式
我们知道，ECMAScript 中的构造函数可用来创建特定类型的对象。像 Object 和 Array 这样的原生构造函数，在运行时会自动出现在执行环境中。此外，也可以创建自定义的构造函数，从而定义自定义对象类型的属性和方法。
构造函数与普通函数的唯一区别就是调用方式不同，构造函数毕竟也是函数，不存在定义构造函数的特殊语法。任何函数，只要通过 new 操作符来调用，那它就可以作为构造函数；而任何函数，如果不通过 new 操作符来调用，那它跟普通函数也不会有什么两样。
构造函数的首字母名称都是要大写的，非构造函数则以小写字母开头。如此可以更好地辨别二者。
使用 new 操作符调用构造函数会执行以下操作：
- 在内存中创建一个新对象；
- 将构造函数的作用域赋给新对象（因此 this 就指向了这个新对象）；
- 执行构造函数中的代码（为这个新对象添加属性）；
- 返回新对象。
创建自定义的构造函数意味着将来可以将它的实例标识为一种特定的类型；而这正是构造函数模式相较于工厂模式的优点。
构造函数定义的方法会在每个实例上都创建一遍，这会导致相同的函数会被重复定义。这个问题可以通过把函数定义到构造函数外部来解决。但是这个解决办法虽然解决了相同逻辑的函数重复定义的问题，却也打乱了全局作用域。所以又产生了原型模式来解决这一问题。
2.3 原型模式
每个函数都有一个 prototype（原型）属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。即 prototype 就是通过调用构造函数而创建的那个对象实例的原型对象。
使用原型对象的好处是可以让所有对象实例共享它所包含的属性和方法。即不必在构造函数中定义对象实例的信息，而是可以将这些信息直接添加到原型对象中。
- 理解原型对象
无论何时，只要创建了一个新函数，就会根据一组特定的规则为该函数创建一个 prototype 属性，这个属性指向函数的原型对象。
在默认情况下，所有原型对象都会自动获得一个 constructor（构造函数）属性，这个属性包含一个指向 prototype 属性所在函数的指针。而通过这个构造函数，我们还可继续为原型对象添加其他属性和方法。
创建了自定义的构造函数之后，其原型对象默认只会取得 constructor 属性；至于其他方法，则都是从 Object 继承而来的。当调用构造函数创建一个新实例后，该实例的内部将包含一个指针（内部属性），指向构造函数的原型对象。ECMA-262 第 5 版中管这个指针叫[[Prototype]]。虽然在脚本中没有标准的方式访问[[Prototype]]，但 Firefox、Safari 和 Chrome 在每个对象上都支持一个属性__proto__（_proto_属性用来读取或设置当前对象的prototype 属性）；而在其他实现中，这个属性对脚本则是完全不可见的。不过，这个连接存在于实例与构造函数的原型对象之间，而不是存在于实例与构造函数之间。
虽然在所有实现中都无法访问到[[Prototype]]，但可以通过
isPrototypeOf()方法来确定对象之间是否存在这种关系。从本质上讲，如果[[Prototype]]指向调用 isPrototypeOf()方法的对象，那么这个方法就返回 true
ECMAScript 5 增加了一个新方法，叫 Object.getPrototypeOf()，在所有支持的实现中，这个方法返回[[Prototype]]的值。
每当代码读取某个对象的某个属性时，都会执行一次搜索，目标是具有给定名字的属性。搜索首先从对象实例本身开始。如果在实例中找到了具有给定名字的属性，则返回该属性的值；如果没有找到，则继续搜索指针指向的原型对象，在原型对象中查找具有给定名字的属性。如果在原型对象中找到了这个属性，则返回该属性的值。
虽然可以通过对象实例访问保存在原型中的值，但却不能通过对象实例重写原型中的值。如果我们在实例中添加了一个属性，而该属性与实例原型中的一个属性同名，那我们就在实例中创建该属性，该属性将会屏蔽原型中的那个属性。
如：
function Person(){
} Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){ alert(this.name);
}; var person1 = new Person();
var person2 = new Person(); person1.name = "Greg";
alert(person1.name); //"Greg"——来自实例
alert(person2.name); //"Nicholas"——来自原型
当为对象实例添加一个属性时，这个属性就会屏蔽原型对象中保存的同名属性；换句话说，添加这个属性只会阻止我们访问原型中的那个属性，但不会修改那个属性。即使将这个属性设置为 null，也只会在实例中设置这个属性，而不会恢复其指向原型的连接。不过，使用 delete 操作符则可以完全删除实例属性，从而让我们能够重新访问原型中的属性。
如：
function Person(){
} Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.job = "Software Engineer";
Person.prototype.sayName = function(){ alert(this.name);
}; var person1 = new Person();
var person2 = new Person(); person1.name = "Greg";
alert(person1.name); //"Greg"——来自实例
alert(person2.name); //"Nicholas"——来自原型delete person1.name;
alert(person1.name); //"Nicholas"——来自原型
使用 hasOwnProperty()方法可以检测一个属性是存在于实例中，还是存在于原型中。这个方法是从 Object 继承来的，故只在给定属性存在于对象实例中时，才会返回 true。通过使用 hasOwnProperty()方法，什么时候访问的是实例属性，什么时候访问的是原型属性就一清二楚了。
ECMAScript 5 的 Object.getOwnPropertyDescriptor()方法只能用于实例属性，要取得原型属性的描述符，必须直接在原型对象上调用Object.getOwnPropertyDescriptor()方法。
- 原型与
in操作符
有两种方式使用 in 操作符：单独使用和在 for-in 循环中使用。
在单独使用时，in 操作符会在通过对象能够访问给定属性时返回 true，无论该属性存在于实例中还是原型中。
无论属性存在于实例中还是存在于原型中，只要同时使用hasOwnProperty()方法和in操作符，就可以确定该属性到底是存在于对象中，还是存在于原型中。 因为 in 操作符只要通过对象能够访问到属性就返回 true，hasOwnProperty()只在属性存在于实例中时才返回 true，故只要 in 操作符返回 true 而hasOwnProperty()返回 false，就可以确定属性是原型中的属性。在使用 for-in 循环时，返回的是所有能够通过对象访问的、可枚举的（enumerated）属性，其中既包括存在于实例中的属性，也包括存在于原型中的属性。屏蔽了原型中不可枚举属性（即将
[[Enumerable]]标记为 false 的属性）的实例属性也会在 for-in 循环中返回，因为根据规定，所有开发人员定义的属性都是可枚举的——只有在 IE8 及更早版本中例外 (IE 早期版本的实现中存在一个 bug，即屏蔽不可枚举属性的实例属性不会出现在 for-in 循环中)。
要取得对象上所有可枚举的实例属性，可使用ES5的object.keys()方法。该方法接收一个对象作为参数，返回一个包含所有可枚举属性的字符串数组。
function Person(){};Person.prototype.name = 'Lily';Person.prototype.age = 17;Person.prototype.job = 'Teacher';Person.prototype.sayName = function(){alert(this.name);}var keys = Object.keys(Person.prototype);alert(keys); //"name,age,job,sayName";alert(Array.isArray(keys)); //truealert(keys.length); //4var person1 = new Person();person1.name = "Candy";person1.job = "Singer";var keys2 = Object.keys(person1);alert(keys2); //"name,job";
constructor 属性不可枚举。若想获得所有实例属性（无论是否可枚举），则可使用Object.getOwnPropertyName() 方法。
function Person(){};Person.prototype.name = 'Lily';Person.prototype.age = 17;Person.prototype.job = 'Teacher';Person.prototype.sayName = function(){alert(this.name);}var keys = Object.getOwnPropertyName(Person.prototype);alert(keys); //"constructor,name,age,job,sayName";
将 Person.prototype 设置为等于一个以对象字面量创建的新对象，是更为简单的原型语法。但这样的语法，本质上是完全重写了默认的 prototype 对象，使得 constructor 属性不再指向Person了（指向Object构造函数）。
可通过以下方式将constructor属性重新指向Person:
function Person(){};Person.prototype = {constructor: Person, //重设constructor属性name: 'Lily',age: 17,job: 'Teacher',sayName: function(){alert(this.name);}};
但这种方式会导致它的 [[Enumerable]]（可枚举）特性被设置为true。
对原型对象所做的任何修改都能立即从实例上反映出来，即便是先创建了实例后修改原型：
var friend = new Person();Person.prototype.sayHi = function(){alert('Hi!');};friend.sayHi(); //"Hi!"
但若是重写整个原型对象，情况就不一样了：
var friend = new Person();Person.prototype = {construcor: Person,name: 'Candy',age: 22,job: 'Dancer',sayName: function(){alert(this.name);}};friend.sayName(); //error
因为，调用构造函数时会为实例添加一个指向最初原型的指针，而把原型修改为另外一个对象就等同于切断了实例与最初原型之间的联系。
实例中的指针仅指向原型，而不指向构造函数。
重写原型对象切断了现有原型与任何之前已经存在的对象实例之间的联系，他们引用的仍然是最初的原型。
原型对象的弊端：当属性中包含引用类型值时，修改实例中相应的引用类型值将会间接修改原型中的引用类型值。
2.4 组合使用构造函数模式和原型模式
创建自定义类型的最常见方式，就是组合使用构造函数模式与原型模式。构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。结果，每个实例都会有自己的一份实例属性的副本，但同时又共享着对方法的引用，最大限度地节省了内存。另外，这种混成模式还支持向构造函数传递参数。
这种构造函数与原型混成的模式，是目前在 ECMAScript 中使用最广泛、认同度最高的一种创建自定义类型的方法。可以说，这是用来定义引用类型的一种默认模式。
2.5 动态原型模式
动态原型是把所有信息都封装在了构造函数中，而通过在构造函数中初始化原型（仅在必要的情况下），又保持了同时使用构造函数和原型的优点。换句话说，可以通过检查某个应该存在的方法是否有效，来决定是否需要初始化原型，如：
function Person(name,age,job){this.name = name;this.age = age;this.job = job;//方法if(typeof this.sayName != "function"){Person.prototype.sayName = function(){alert(this.name);}}
}
var friend = new Person("Tony",21,"teacher");
friend.sayName();
- sayName()方法不存在的情况下，才会将他添加到原型中。
- 这段代码只会在初次调用构造函数时才会执行。此后，原型已经完成初始化，不需要再做什么修改了，不过这里对原型所做的修改，能够立即在所有实例中得到反映，因此，这种方法确实so good。
- 其中，if语句检查的可以是初始化之后应该存在的任何属性和方法——不必用一大堆if语句检查每个属性和方法，只要检查其中一个即可。
对于才用这种模式创建的对象，还可以使用instanceof操作符确定它的类型。
注意：使用动态原型模式时，不能使用对象字面量重写原型，如果在已经创建了实例的情况下重写原型，就会切断现有实例和原型之间的联系。
2.6 寄生构造函数
在前述的几种模式都不适用的情况下，可以使用寄生（parasitic）构造函数模式。寄生构造函数的基本思想是创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象;但从表面上看，这个函数又很像是典型的构造函数。如：
function Person(name, age, job){ var o = new Object(); o.name = name; o.age = age; o.job = job; o.sayName = function(){ alert(this.name); }; return o;
}
var friend = new Person("Nicholas", 29, "Software Engineer");
friend.sayName(); //"Nicholas"
在这个例子中，Person 函数创建了一个新对象，并以相应的属性和方法初始化该对象，然后又返回了这个对象。
除了使用 new 操作符并把使用的包装函数叫做构造函数之外，这个模式跟工厂模式其实是一模一样的。构造函数在不返回值的情况下，默认会返回新对象实例。而通过在构造函数的末尾添加一个 return 语句，可以重写调用构造函数时返回的值。这个模式可以在特殊的情况下用来为对象创建构造函数。若想创建一个具有额外方法的特殊数组，又由于不能直接修改 Array 构造函数，因此可以使用这个模式。
关于寄生构造函数模式，需要注意的是：首先，返回的对象与构造函数或者与构造函数的原型属性之间没有关系，即也就是说，构造函数返回的对象与在构造函数外部创建的对象没有什么不同。为此，不能依赖 instanceof 操作符来确定对象类型。由于存在上述问题，我们建议在可以使用其他模式的情 况下，不要使用这种模式。
2.7 稳妥构造函数模式
道格拉斯·克罗克福德（Douglas Crockford）发明了 JavaScript 中的稳妥对象（durable objects）这个概念。稳妥对象，指的是没有公共属性，而且其方法也不引用 this 的对象。
稳妥对象最适合在一些安全的环境中（这些环境中会禁止使用 this 和 new），或者在防止数据被其他应用程序（如 Mashup程序）改动时使用。
稳妥构造函数遵循与寄生构造函数类似的模式，但有两点不同：
- 新创建对象的实例方法不引用 this；
- 二是不使用 new 操作符调用构造函数。
3. 继承
继承是 OO 语言中的一个最为人津津乐道的概念。许多 OO 语言都支持两种继承方式：接口继承和实现继承。
接口继承只继承方法签名，而实现继承则继承实际的方法。由于函数没有签名，在 ECMAScript 中无法实现接口继承。ECMAScript 只支持实现继承，而且其实现继承主要是依靠原型链来实现的。
3.1 原型链
ECMAScript 中描述了原型链的概念，并将原型链作为实现继承的主要方法。其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。简单回顾一下构造函数、原型和实例的关系：每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针。故而，使原型对象等于另一个类型的实例，就实现继承：
A.prototype = new B(); //继承了B
假如让原型对象等于另一个类型的实例。则此时的原型对象将包含一个指向另一个原型的指针，相应地，另一个原型中也包含着一个指向另一个构造函数的指针。假如另一个原型又是另一个类型的实例，那么上述关系依然成立，如此层层递进，就构成了实例与原型的链条。这就是所谓原型链的基本概念。
原型链继承的实质就是重写原型对象。
当以读取模式访问一个实例属性时，首先会在实例中搜索该属性，若没有找到该属性，则会继续搜索实例的原型。在通过原型链继承的情况下，搜索过程就得以沿着原型链继承向上。
所以引用类型都默认继承了Object，这个继承也是通过原型链实现的。所以函数的1默认原型都是Object的实例。P164
确定原型和实例之间的关系：使用 instanceof 和 isPrototypeOf() 方法。
alert(A instanceof B); //boolean
// A是B的实例，则返回true，反之返回false
alert(A.prototype.isPrototypeOf(B)); //boolean//A的原型也是B的原型
注：
- 给原型添加方法的代码一定要放在替换原型的语句之后。
- 在通过原型链实现继承时，不能使用对象字面量创建原型方法，这样会重写原型方法。
- 原型链继承的弊端：问题源于包含引用类型值的原型，包含引用类型值的原型属性会被所有实例共享。
原型链的问题：
- 最主要的问题来自包含引用类型值的原型。在原型模式中学到了包含引用类型值的原型属性会被所有实例共享；这也正是为什么要在构造函数中，而不是在原型对象中定义属性的原因。在通过原型来实现继承时，原型实际上会变成另一个类型的实例。于是，原先的实例属性也就顺理成章地变成了现在的原型属性了。
- 在创建子类型的实例时，不能向超类型的构造函数中传递参数。实际上，应该说是没有办法在不影响所有对象实例的情况下，给超类型的构造函数传递参数。有鉴于此，再加上前面刚刚讨论过的由于原型中包含引用类型值所带来的问题，实践中很少会单独使用原型链。
3.2 借助构造函数
在解决原型中包含引用类型值所带来的问题的过程中，开发人员使用一种叫做借用构造函数的技术（有时也叫做伪造对象或经典继承）。借用构造函数的基本思想相当简单，即在子类型构造函数的内部调用超类型构造函数。因为函数只不过是在特定环境中执行代码的对象，因此通过使用apply()和call()方法也可以在新创捷的对象上执行构造函数：
function SuperType(){ this.colors = ["red", "blue", "green"];
}
function SubType(){ //继承了 SuperType SuperType.call(this);
}
var instance1 = new SubType();
instance1.colors.push("black");
alert(instance1.colors); //"red,blue,green,black"
var instance2 = new SubType();
alert(instance2.colors); //"red,blue,green"
- 传递参数
相对于原型链而言，借用构造函数有一个很大的优势，即可以在子类型构造函数中向超类型构造函数传递参数。
function SuperType(name){ this.name = name;
}
function SubType(){ //继承了 SuperType，同时还传递了参数SuperType.call(this, "Nicholas"); //实例属性this.age = 29;
}
var instance = new SubType();
alert(instance.name); //"Nicholas";
alert(instance.age); //29
SuperType 只接受一个参数 name，该参数会直接赋给一个属性。在 SubType 构造函数内部调用 SuperType 构造函数时，实际上是为 SubType 的实例设置了 name 属性。为了确保SuperType 构造函数不会重写子类型的属性，可以在调用超类型构造函数后，再添加应该在子类型中定义的属性。
- 借用构造函数的问题
如果仅仅是借用构造函数，那么也将无法避免构造函数模式存在的问题——方法都在构造函数中定义，因此就无法复用函数了。而且，在超类型的原型中定义的方法，对子类型而言也是不可见的，结果所有类型都只能使用构造函数模式。因此借用构造函数的技术也很少单独使用。
3.3 组合继承
组合继承（combination inheritance），有时候也叫做伪经典继承，指的是将原型链和借用构造函数的技术组合到一块，从而发挥二者之长的一种继承模式。其背后的思路是使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。这样，既通过在原型上定义方法实现了函数复用，又能够保证每个实例都有它自己的属性。
组合继承避免了原型链和借用构造函数的缺陷，融合了它们的优点，成为 JavaScript 中最常用的继承模式。而且，instanceof 和 isPrototypeOf()也能够用于识别基于组合继承创建的对象。
缺点：无论什么情况下，都会调用两次超类型构造函数，一次是在创建子类型原型的时候，另一次是在子类型构造函数内部。
3.4 原型式继承
借助原型可以基于已有的对象创建新对象，同时还不必因此创建自定义类型。
function object(o){function F(){};F.prototype = 0;return new F();
}
在 object()函数内部，先创建了一个临时性的构造函数，然后将传入的对象作为这个构造函数的 原型，最后返回了这个临时类型的一个新实例。从本质上讲，object()对传入其中的对象执行了一次浅复制。
这种原型式继承，要求你必须有一个对象可以作为另一个对象的基础。如果有这么一个对象的话，可以把它传递给 object() 函数，然后再根据具体需求对得到的对象加以修改即可。
ECMAScript 5 通过新增 Object.create(对象，（可选）新对象定义额外属性的对象)方法规范化了原型式继承。
var person = {name: "Nicholas",friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = Object.create(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");
var yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");
alert(person.friends); //"Shelby,Court,Van,Rob,Barbie"
Object.create()方法的第二个参数与Object.defineProperties()方法的第二个参数格式相同：每个属性都是通过自己的描述符定义的。以这种方式指定的任何属性都会覆盖原型对象上的同名属性。
注意：在没有必要兴师动众地创建构造函数，而只想让一个对象与另一个对象保持类似的情况下，原型式继承是完全可以胜任的。不过别忘了，包含引用类型值的属性始终都会共享相应的值，就像使用原型模式一样。
缺点：包含引用类型值的属性始终都会共享相应的值，就像使用原型模式一样。
3.5 寄生式继承
寄生式（parasitic）继承是与原型式继承紧密相关的一种思路，并且同样也是由克罗克福德推而广之的。寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真地是它做了所有工作一样返回对象。
- 在主要考虑对象而不是自定义类型和构造函数的情况下，寄生式继承也是一种有用的模式。前面示范继承模式时使用的 object()函数不是必需的；任何能够返回新对象的函数都适用于此模式。
- 使用寄生式继承来为对象添加函数，会由于不能做到函数复用而降低效率；这一点与构造函数模式类似。
3.6 寄生组合式继承
虽然 组合继承 被认为是JavaScript 中最常用的集成模式，但它仍然有一个问题：就是无论什么情况下，都会调用两次超类型构造函数：一次是在创建子类型原型的时候，另一次是在子类型构造函数内部。对于这个问题，解决办法就是使用寄生组合式继承。
寄生组合式继承，就是通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。其背后的基本思路是：不必为了指定子类型的原型而调用超类型的构造函数，我们所需要的无非就是超类型原型的一个副本而已。
本质上，就是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。
寄生组合式继承的基本模式如下所示：
function inheritPrototype(subType, superType){ var prototype = object(superType.prototype); //创建对象prototype.constructor = subType; //增强对象subType.prototype = prototype; //指定对象
}
优点：效率高，值调用一次超类型原型的构造函数，原型链还能保持不变，能正常使用instanceof和isPrototypeOf( )。是最理想的继承范式。
JavaScript高级程序设计--学习笔记（第六章）相关推荐
- javascript高级程序设计 学习笔记 第五章 上
第五章 引用类型的值(对象)是引用类型的一个实例.在 ECMAScript 中,引用类型是一种数据结构, 用于将数据和功能组织在一起.它也常被称为类,但这种称呼并不妥当.尽管 ECMAScri ...
- JavaScript高级程序设计学习笔记（三）
分享一下第五章(引用类型)的笔记,内容比较多,我拆成了两部分,今天这部分是关于Object.Array.Date和RegExp类型的. 以下的笔记是书上一些我以前学习的时候,没有太重视的js基础知识, ...
- javascript高级程序设计学习笔记
javascript高级程序设计,当枕头书已经好久了~zz 现在觉得自己在js的开发上遇到了一些瓶颈,归根究底还是基础太薄弱,所以重新刷一遍js高程希望有更新的认识. 一.javascript简介 ...
- 《JavaScript 高级程序设计》笔记 第7章及以后
第7章 函数表达式 匿名函数的name属性是空字符串: 闭包是函数:闭包是有权访问另一个函数作用域中变量的函数:(P181 副作用,解释了点击li弹出循环最后值的原因) 当某个函数第一次被调用时,会创 ...
- 重学《JavaScript 高级程序设计》笔记 第6章对象
第6章 面向对象的程序设计 ECMAScript中没有类的概念: 1.创建对象-历史 1.1 创建实例,添加方法和属性 → 对象字面量 缺点: 使用同一接口创建很多对象,产生大量重复代码 var pe ...
- javascript高级程序设计学笔记——第五章 引用类型
对象是某个特定引用类型的实例:新对象是使用new操作符后跟构造函数来创建的,构造函数本身就是一个函数,只不过该函数是出于创建新对象的目的而存在的: 一.Object类型 创建Object实例的方式有两 ...
- JavaScript高级程序设计学习笔记二（在HTML中使用JavaScript）
在 HTML 中使用 JavaScript 在html中使用JavaScript脚本有两种方式一种是嵌入在HTML中的脚本,另一种是引入外部的脚本.两种方式都离不开<script>元素. ...
- JavaScript高级程序设计学习笔记第二十章--JSON
1.JSON:JavaScript Object Notation, JavaScript 对象表示法. 2.最重要的是要理解它是一种数据格式,不是一种编程语言.虽然具有相同的语法形式,但 JSON ...
- JavaScript高级程序设计---学习笔记（四）
1.全局变量不能通过delete操作符删除,而直接在window对象上定义的属性可以. var age = 29;window.color = "red";delete age;/ ...
最新文章
- android 百分号,关于Android资源文件中出现百分号的问题
- 共享内存简介和mmap 函数
- C#基础 字符串读取/写入文本文件 代码示例
- MFC不能多线程操作控件的原因
- Python设置默认语言编码
- ie浏览器怎么取消代理浏览器_微软和IE渐行渐远，IE浏览器终将成为回忆
- [转]最长回文字符串
- 【腾讯bugly干货】QQ空间直播秒开优化实践
- Alameda：最初同意对Reef投资8000万美元，但支付2000万美元后Reef拒绝了随后的交易
- Python:通过命令行发送新浪微博
- JAVA 正则表达式4种常用的功能
- 【BZOJ2388】—旅行规划（分块+凸包）
- 力扣-53 最大子序和
- 《C++代码设计与重用》——2.7 转型
- unix网络编程——网络基础
- 输入一个整数,判断它是几位数
- HTML网页设计与制作：电影网站设计——电影泰坦尼克号(4页) HTML+CSS+JavaScript
- ip地址配置 mongodb_【已解决】给MongoDB限制IP访问
- android串口通信——android-serialport-api
- ubuntu apt安装java_Ubuntu 16.04 apt方式安装JDK并且配置Java开发环境详解