继承
在 ECMAScript 中由于函数没有签名，只支持实现继承，依靠原型链来实现。
1.原型链
基本思想：利用原型让一个引用类型继承另一个引用类型的属性和方法。
function SuperType() {
this.property = true;
}
SuperType.prototype.getSuperValue = function() {
return this.property;
}
function SubType() {
this.subproperty = false;
}
// 继承了 SuperType 设置原型为超类的实例
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function() {
return this.subproperty;
}
var instance = new SubType();
// 调用到超类的方法
alert(instance.getSuperValue()); // true
以上的来个类型都分别有一个属性和方法， SubType 继承是通过创建 SuperType 的实例，将该实例赋给 SubType.prototype 实现，本质是重写原型对象。
1.1 别忘记默认的原型
所有的引用类型默认都继承了 Object，这个继承也是通过原型链实现。所有函数的默认原型都是 Object 的实例，因此默认原型都会包含一个内部指针（[[prototype]] 或 __proto__） 指向 Object.prototype。
1.2 确定原型和实例的关系
- 使用
instanceof操作符，测试实例与原型链中出现过的构造函数，结果会返回true。
instance instanceof Object; // true
instance instanceof SuperType; // true
instance instanceof SubType; // true
- 使用
isPrototypeOf()方法，只要是原型链中出现过的原型，也会返回true。
Object.prototype.isPrototypeOf(instance); // true
SuperType.prototype.isPrototypeOf(instance); // true
SubType.prototype.isPrototypeOf(instance); // true
1.3 谨慎地定义方法
给原型添加方法的代码须放在替换原型的语句之后（否则方法是在默认的原型上，替换后的原型是超类的实例）。
function SuperType() {
this.property = true;
}
SuperType.prototype.getSuperValue = function() {
return this.property;
}
function SubType() {
this.subproperty = false;
}
// 继承了 SuperType 替换原型实例
SubType.prototype = new SuperType();
// 添加了新方法（后置）
SubType.prototype.getSubValue = function() {
return this.subproperty;
}
// 重写超类型中的方法（后置）
SubType.prototype.getSuperValue = function() {
return this.false;
}
var instance = new SubType();
// 调用到超类的方法
alert(instance.getSuperValue()); // true
1.4 原型链的问题
包含引用类型值的原型属性会被所有实例共享，因此需要在构造函数而不是原型对象中定义属性。
2. 借用构造函数
在子类型构造函数的内部调用超类型构造函数，同时通过使用 apply() 和 call() 方法也可以在（将来）新创建的对象上执行构造函数。
function SuperType() {
this.colors = ["red", "blue", "green"];
}
function SubType() {
// 继承了 SuperType
SuperType.call(this);
}
var ins1 = new SubType();
ins1.colors.push("black");
alert(ins1.colors); // "red, blue, green, black"
var ins2 = new SubType();
alert(ins2.colors); // "red, blue, green"
2.1 传递参数
借用构造函数可以在子类型构造函数中向超类型构造函数传递参数。
function SuperType(name) {
this.name = name;
}
function SubType() {
// 继承了 SuperType，同时传递了参数
SuperType.call(this, "Nicklas");
// 实例属性
this.age = 29;
}
var ins = new SubType();
alert(ins.name); // "Nicklas"
alert(ins.age); // 29
2.2 借用构造函数的问题
仅借用构造函数，无法避免构造函数模式的问题，即方法都在构造函数中定义，无法实现复用函数，同时，在超类型原型中定义的方法，对子类型也是不可见的，因此构造函数技术很少单独使用。
3. 组合继承
将原型链和借用构造函数的技术组合到一块，思路是使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承，一方面通过原型上定义方法实现函数复用，又能保证每个实例都有自己的属性。
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.sayAge = function() {
alert(this.age)
}
var ins1 = new SubType("Nicklas", 29);
ins1.colors.push("black");
alert(ins1.colors); // "red, blue, green, black"
ins1.sayName(); // "Nicklas"
ins1.sayAge(); // 29
var ins2 = new SubType("Greg", 27);
alert(ins2.colors); // "red, blue, green"
ins2.sayName(); // "Greg"
ins2.sayAge(); // 27
4. 原型式继承
借助原型可以基于已有的对象创建新对象，同时还不必因此创建自定义类型。
function object(o) {
function F() { }
F.prototype = o;
return new F();
}
在 object() 函数内部，先创建一个临时性的构造函数，然后将传入的对象作为这个构造函数的原型，最后返回了这个临时类型的一个新实例。
5. 寄生式继承
寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真的是做了所有工作一样返回对象。
function createAnother(ori) {
var clone = object(ori); // 通过调用函数创建一个新对象
clone.sayHi = function() { // 以某种方式来增强这个对象
alert("hi");
};
retrun clone;
}
6. 寄生组合式继承
组合继承最大的问题是任何时候都会两次调用超类型构造函数：一次是在创建子类原型的时候，一次是在子类型构造函数内部。
寄生组合式继承即通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。不必为了制定子类型的原型而调用超类型的构造函数，因为我们所需要的无非就是超类型原型的一个副本而已。本质上，就是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。
function inheritPrototype(subType, superType) {
var protptype = object(superType.prototype); // 创建对象
prototype.constructor = subType; // 增强对象
subType.prototype = prototype; // 指定对象
}
后记
至此，第六章算是结束了，但是整个过程有点痛苦，因为从理解层面来讲，这一章的篇幅还是蛮大的，而且本书中这一章写得太学术了，写笔记也是挺累的，而且自认为这三节笔记写得质量有点低，但是一直跑不出这章太影响效率了，计划在本书笔记完结后再来做一些简略的补充和完善。