js继承的方式

继承，必须要提供个父类（继承谁，提供继承的属性）

// 父类
function Person(name) { // 给构造函数添加参数
   this.name = name
   this.sum = function(){
      alert(this.name)
   }
}
Person.prototype.age = 20  // 给构造函数添加了原型属性

1、原型链继承

// 原型链继承
function Per() {
   this.name = 'Json'
}
Per.prototype = new Person()
var per1 = new Per()
console.log(per1.age)  // 20
console.log(per1 instanceof Person)  // true
// instanceof 判断元素是否在另一个元素的原型链上
// per1 继承了Person 的属性，返回true

重点：

• 让新实例的原型等于父类的实例

特点：

• 实例可继承的属性有：实例的构造函数的属性，父类构造函数属性， 父类原型的属性（新实例不会继承父类实例的属性）

缺点：

• 新实例无法向父类构造函数传参
• 继承单一
• 所有新实例都会共享父类实例的属性（原型上的属性是共享的，一个实 例修改了原型属性，另一个实例的原型属性也会被修改）

2、借用构造函数继承

// 借用构造函数继承
function Con() {
   Person.call(this,'Json')  // 重点
   this.age = 12
}
var con1 = new Con()
console.log(con1.name) // 'Json'
console.log(con1.age)  // 12
console.log(con1 instanceof Person) // false

重点：

• 用 call() 和 apply() 将父类构造函数引入子类函数（在子类函数中做了父类函数的自执行（复制））

特点：

• 只继承了父类构造函数的属性，没有继承父类原型的属性
• 解决了原型继承所有缺点
• 可以继承多个构造函数属性（call多个）
• 在子实例中可向父实例传参

缺点：

• 只能继承父类构造函数的属性
• 无法实现构造函数的复用（每次用每次都要重新调用）
• 每个新实例都有父类构造函数的副本，臃肿

3、组合继承（组合原型链继承和借用构造函数继承） 常用

// 组合原型链和构造函数继承
function SubType(name) {
   Person.call(this,name) // 借用构造函数模式
}
SubType.prototype = new Person()  // 原型链继承
var sub = new SubType('Tom')
console.log(sub.name)  // Tom 继承了构造函数属性
console.log(sub.age)   // 10 继承可父类原型的属性

重点：

• 结合了两种模式的优点，传参和复用

特点：

• 可以继承父类原型上的属性，可以传参，可复用
• 每个新实例引入的构造函数属性是私有的

缺点：

• 调用了两次父类构造函数（耗内存），子类的构造函数会代替原型上的那个父类构造函数

原型式继承

// 先封装一个函数容器，用来输出对象和承载继承的原型
function Content(obj) {
   function Fn(){}
   Fn.prototype = obj  // 继承了传入的参数
   return new Fn()  // 返回函数对象
}
var sup = new Person() // 拿到父类的实例
var sup1 = Content(sup)
console.log(sup1.age)  // 10 继承了父类函数的属性

重点：

• 用一个函数包装一个对象，然后返回这个函数的调用，这个函数就变成了可以随意增添属性的实例或对象，object.create() 就是这个原理

特点：

• 类似于复制一个对象，用函数来包装

缺点：

• 所有实例都会继承原型上的属性
• 无法实现复用（新实例属性都是后面添加的）

5、寄生式继承

function Content(obj) {
   function Fn(){}
   Fn.prototype = obj  // 继承了传入的参数
   return new Fn() // 返回函数对象
}
var sup = new Person()
// 以上是原型式继承，给原型式继承再套个壳子传递参数
function subobject(obj){
   var sub = Content(obj)
   sub.name = 'Tom'
   return sub
}
var sup2 = subobject(sup)
// 这个函数经过声明之后就成了可增添属性的对象
console.log(typeof subobject)  // function
console.log(typeof sup2)  // object
console.log(sup2.name)  // 'Tom' 返回了个sub对象，继承了sub的属性

重点：

• 就是给原型式继承外面套了一个壳子

优点：

• 没有创建自定义类型，因为只是套了个壳子返回对象，这个函数顺理成章就成了创建的新对象

缺点：

• 没有用到原型，无法复用

6、寄生组合式继承（常用）

寄生：在函数内返回对象然后调用
组合：

• 函数的原型等于另一个实例
• 在函数中用apply或者call引入一个构造函数，可传参

// 寄生
function Content(obj) {
   function Fn(){}
   Fn.prototype = obj
   return new Fn()
}
// Content 就是Fn 实例的另一种表示法
var con = Content(Person.prototype)
// con 实例（Fn 实例）的原型继承了父类函数的原型
// 上述更像是原型继承，只不过只继承了原型属性

// 组合
function Sub(){
   Person.call(this) // 这个继承了父类构造函数的属性
}  // 解决了组合式两次调用构造函数属性的缺点

// 重点
Sub.prototype = con  // 继承了con实例
con.constructor = Sub // 一定要修复实例
var sub1 = new Sub()
// Sub 的实例就继承了构造函数属性，父类实例，con 的函数属性
console.log(sub1.age) // 10

// 上述和一下例子的效果是一样的
function Fn(){}
Fn.prototype = Person.prototype
function Sub(){
   Person.call(this)
}
Sub.prototype = new Fn()
var sub2 = new Sub()
console.log(sub2.age)

重点：修复了组合继承的问题