7.18 - 8.3（继承）

很多面向对象语言都支持两种继承：接口继承和实现继承， 很多面向对象语言都支持两种继承：接口继承和实现继承， ECMAScript 中是不可能的，因为函数没有签名。实现继承是 ECMAScript 唯一支持的继承方式，而这主要是通过原型链实现的。

原型链

通过原型继承多个引用类型的属性和方法。

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; 
}; 
let instance = new SubType(); 
console.log(instance.getSuperValue()); // true

• SubType.prototype 现在是 SuperType 的一个实例
• SubType.prototype 的 constructor 属性被重写为指向 SuperType，所以 instance.constructor 也指向 SuperType。

• 调用 instance.getSuperValue()经过了 3 步搜索：instance、 SubType.prototype 和 SuperType.prototype，最后一步才找到这个方法。对属性和方法的搜索会 一直持续到原型链的末端 。

  默认原型

• 所有引用类型都继承自 Object，也是通过原型链实现的

  原型链与继承关系

• 使用 instanceof 操作符，如果是当前实例就返回true

• isPrototypeOf() 只要原型链中包含这个原型，这个方法就返回 true ；

  Object.prototype.isPrototypeOf(instance); // true

  原型链上的方法

• 在继承构造函数上的方法，如果和父构造函数同名，会覆盖父构造函数上的方法

• 注意：如果是重写了prototype，继承就失效了

  // 通过对象字面量添加新方法，这会导致上一行无效
  SubType.prototype = { 
  getSubValue() { 
  return this.subproperty; 
  }, 
  someOtherMethod() { 
  return false; 
  } 
  };

  原型链的问题

• 原型中包含的引用值会在所有实例间共享，这也是为什么属性通常会 在构造函数中定义而不会定义在原型上的原因。

• 子类型在实例化时不能给父类型的构造函数传参

  盗用构造函数

  有时也称作“对象伪装”或“经典继承”

function SuperType(name){ 
 this.name = name; 
} 
function SubType() { 
 // 继承 SuperType 并传参
 SuperType.call(this, "Nicholas"); 
 // 实例属性
 this.age = 29; 
} 
let instance = new SubType(); 
console.log(instance.name); // "Nicholas"; 
console.log(instance.age); // 29

• 盗用构造函数的一个优点就是可以在子类构造函数中向父类构造函数传参。
• 主要缺点: 必须在构造函数中定义方法,函数不能重用，子类也不能访问父类原型上定义的方法。

  组合继承

  也叫伪经典继承， 基本思路是使用原型链继承原型上的属性和方法，而通过盗用构造函数继承实例属性。 组合继承弥补了原型链和盗用构造函数的不足，是 JavaScript 中使用最多的继承模式。而且组合继承也保留了 instanceof 操作符和 isPrototypeOf()方法识别合成对象的能力

function SuperType(name){ 
 this.name = name; 
 this.colors = ["red", "blue", "green"]; 
} 
SuperType.prototype.sayName = function() { 
 console.log(this.name); 
}; 
function SubType(name, age){ 
 // 继承属性
 SuperType.call(this, name); 
 this.age = age; 
} 
// 继承方法
SubType.prototype = new SuperType(); 
SubType.prototype.sayAge = function() { 
 console.log(this.age); 
}; 
let instance1 = new SubType("Nicholas", 29); 
instance1.colors.push("black"); 
console.log(instance1.colors); // "red,blue,green,black" 
instance1.sayName(); // "Nicholas"; 
instance1.sayAge(); // 29 
let instance2 = new SubType("Greg", 27); 
console.log(instance2.colors); // "red,blue,green" 
instance2.sayName(); // "Greg"; 
instance2.sayAge(); // 27

原型式继承

function object(o) { 
 function F() {} 
 F.prototype = o; 
 return new F(); 
} 
let person = { 
 name: "Nicholas", 
 friends: ["Shelby", "Court", "Van"] 
}; 
let anotherPerson = object(person); 
anotherPerson.name = "Greg"; 
anotherPerson.friends.push("Rob"); 
let yetAnotherPerson = object(person); 
yetAnotherPerson.name = "Linda"; 
yetAnotherPerson.friends.push("Barbie"); 
console.log(person.friends); // "Shelby,Court,Van,Rob,Barbie"

• 使用情况： 你有一个对象，想在它的基础上再创建一个新对象。 你需要把这个对象先传给 object()，然后再对返回的对象进行适当修改 。

• Object.create() — 等同于这个方法，但create方法可以传入第二个参数，与definpropety的第二个参数一致

  let person = { 
  name: "Nicholas", 
  friends: ["Shelby", "Court", "Van"] 
  }; 
  let anotherPerson = Object.create(person, { 
  name: { 
  value: "Greg" 
  } 
  }); 
  console.log(anotherPerson.name); // "Greg"

• 原型式继承非常适合不需要单独创建构造函数，但仍然需要在对象间共享信息的场合。但要记住， 属性中包含的引用值始终会在相关对象间共享，跟使用原型模式是一样的。
  

  寄生式继承

  function createAnother(original){ 
  let clone = object(original); // 通过调用函数创建一个新对象
  clone.sayHi = function() { // 以某种方式增强这个对象
  console.log("hi"); 
  }; 
  return clone; // 返回这个对象
  }

• 通过寄生式继承给对象添加函数会导致函数难以重用，与构造函数模式类似。

寄生式组合继承

• 组合继承其实也存在效率问题。最主要的效率问题就是父类构造函数始终会被调用两次：一次在是 创建子类原型时调用，另一次是在子类构造函数中调用。

  function SuperType(name) { 
  this.name = name; 
  this.colors = ["red", "blue", "green"]; 
  } 
  SuperType.prototype.sayName = function() { 
  console.log(this.name); 
  }; 
  function SubType(name, age){ 
  SuperType.call(this, name); // 第二次调用 SuperType() 
  this.age = age; 
  } 
  SubType.prototype = new SuperType(); // 第一次调用 SuperType() 
  SubType.prototype.constructor = SubType; 
  SubType.prototype.sayAge = function() { 
  console.log(this.age); 
  };

• 实现原理

  function SuperType(name) { 
  this.name = name; 
  this.colors = ["red", "blue", "green"]; 
  } 
  SuperType.prototype.sayName = function() { 
  console.log(this.name); 
  }; 
  function SubType(name, age){ 
  SuperType.call(this, name); // 第二次调用 SuperType() 
  this.age = age; 
  } 
  SubType.prototype = new SuperType(); // 第一次调用 SuperType() 
  SubType.prototype.constructor = SubType; 
  SubType.prototype.sayAge = function() { 
  console.log(this.age); 
  };

• 寄生式组合继承可以算是引用类型继承的最佳模式。