JavaScript常见的继承方式

原型链机制

JavaScript将原型链做为实现继承的主要方法，其基本思想就是利用原型让一个引用类型继承另外一个引用类型的属性和方法。

构造函数和原型还有实例之间的关系：每一个构造函数都有一个原型对象（prototype），原型对象都包含一个指向构造函数的指针（constructor），而实例都包含一个指向原型对象的内部指针 （propto） 。

其实每个Function都是Object基类的一个实例，因此每个Function上都有一个__proto__指向了Object.prototype。当查找一个实例的属性时，会先从这个实例的自定义属性上找，若是没有的话经过__proto__去实例所属类的原型上去找，若是尚未的话再经过原型（原型也是对象，只要是对象就有__proto__属性）的__proto__到Object的原型上去找，一级一级的找，若是没有就undefined。

能够说引用类型之间的继承就是经过原型链机制实现的。

继承方式

1. 原型链继承

这种方式关键在于:子类型的原型为父类型的一个实例对象。

//父类型
function Person(name, age) {
   this.name = name,
   this.age = age,
   this.play = [1, 2, 3]
   this.setName = function () { }
}
Person.prototype.setAge = function () { }
//子类型
function Student(price) {
   this.price = price
   this.setScore = function () { }
}
Student.prototype = new Person() // 子类型的原型为父类型的一个实例对象
var s1 = new Student(15000)
var s2 = new Student(14000)
console.log(s1,s2)
复制代码

但这种方式实现的本质是经过将子类的原型指向了父类的实例，因此 子类的实例就能够经过__proto__访问到 Student.prototype 也就是Person的实例，这样就能够访问到父类的私有方法，而后再经过__proto__指向父类的prototype就能够得到到父类原型上的方法。 因而作到了将父类的私有、公有方法和属性都当作子类的公有属性

子类继承父类的属性和方法是将父类的私有属性和公有方法都做为本身的公有属性和方法， 咱们都知道在操做基本数据类型的时候操做的是值，在操做引用数据类型的时候操做的是地址，若是说父类的私有属性中有引用类型的属性，那它被子类继承的时候会做为公有属性，这样子类一操做这个属性的时候，就会影响到子类二。

s1.play.push(4)
console.log(s1.play, s2.play)
console.log(s1.__proto__ === s2.__proto__)  //true
console.log(s1.__proto__.__proto__ === s2.__proto__.__proto__)  //true
复制代码

s1中play属性发生变化，与此同时，s2中play属性也会跟着变化。

另外注意一点的是， 咱们须要在子类中添加新的方法或者是重写父类的方法时候，切记必定要放到替换原型的语句以后

function Person(name, age) {
   this.name = name,
   this.age = age
}
Person.prototype.setAge = function () {
   console.log("111")
}
function Student(price) {
   this.price = price
   this.setScore = function () { }
}
// Student.prototype.sayHello = function () { }//在这里写子类的原型方法和属性是无效的，
//由于会改变原型的指向，因此应该放到从新指定以后
Student.prototype = new Person()
Student.prototype.sayHello = function () { }
var s1 = new Student(15000)
console.log(s1)
复制代码

优势：

• 很是纯粹的继承关系，实例是子类的实例，也是父类的实例
• 父类新增原型方法和原型属性，子类都能访问到
• 简单，易于实现

缺点：

• 没法实现多继承
• 来自原型对象的全部属性被全部实例共享
• 建立子类实例时，没法向父类构造函数传参
• 要想为子类新增属性和方法，必需要在Student.prototype = new Person() 以后执行，不能放到构造器中

2. 借用构造函数继承（经典继承）

这种方式关键在于:在子类型构造函数中通用call()调用父类型构造函数

function Person(name, age) {
    this.name = name,
    this.age = age,
    this.setName = function () {}
}
Person.prototype.setAge = function () {}
function Student(name, age, price) {
    Person.call(this, name, age)  // 至关于: this.Person(name, age)
    /*this.name = name this.age = age*/
    this.price = price
}
var s1 = new Student('Tom', 20, 15000)
复制代码

这种方式只是实现部分的继承，若是父类的原型还有方法和属性，子类是拿不到这些方法和属性的。

在子类的构造函数中，改变父类的this指向，改变为子类的实例，同时运行父类方法，这样父类中的this.x就变成了 子类的实例.x ,经过这种方法就能够继承了父类的私有属性，且只能继承父类的私有属性和方法。也许你会问那我Person.prototype.call(this) 不就能够继承父类的公有属性和方法么，我只能默默的说一句，call是Function的方法。

console.log(s1.setAge())//Uncaught TypeError: s1.setAge is not a function
复制代码

优势：

• 解决了原型链继承中子类实例共享父类引用属性的问题
• 建立子类实例时，能够向父类传递参数
• 能够实现多继承(call多个父类对象)

缺点：

• 实例并非父类的实例，只是子类的实例
• 只能继承父类的实例属性和方法，不能继承原型属性和方法
• 没法实现函数复用，每一个子类都有父类实例函数的副本，影响性能

3. 组合式继承

这种方式关键在于: 经过调用父类构造，继承父类的属性并保留传参的优势，而后经过将父类实例做为子类原型，实现函数复用。

function Person(name, age) {
    this.name = name,
    this.age = age,
    this.setAge = function () { }
}
Person.prototype.setAge = function () {
    console.log("111")
}
function Student(name, age, price) {
    Person.call(this,name,age)
    this.price = price
    this.setScore = function () { }
}
Student.prototype = new Person()
Student.prototype.constructor = Student//组合继承也是须要修复构造函数指向的
Student.prototype.sayHello = function () { }
var s1 = new Student('Tom', 20, 15000)
var s2 = new Student('Jack', 22, 14000)
console.log(s1)
console.log(s1.constructor) //Student
console.log(p1.constructor) //Person
复制代码

这种方式融合原型链继承和构造函数的优势，是 JavaScript 中最经常使用的继承模式。不过也存在缺点就是不管在什么状况下，都会调用两次构造函数：一次是在建立子类型原型的时候，另外一次是在子类型构造函数的内部，子类型最终会包含父类型对象的所有实例属性，但咱们不得不在调用子类构造函数时重写这些属性。

优势：

• 能够继承实例属性/方法，也能够继承原型属性/方法
• 不存在引用属性共享问题
• 可传参
• 函数可复用

缺点：

• 调用了两次父类构造函数，生成了两份实例

4. 寄生组合式继承（最完美的继承方法）

这种方式关键在于: 借助原型能够基于已有的对象来建立对象，var B = Object.create(A)以A对象为原型，生成了B对象。B继承了A的全部属性和方法。

function Person(name, age) {
    this.name = name,
    this.age = age
}
Person.prototype.setAge = function () {
    console.log("111")
}
function Student(name, age, price) {
    Person.call(this, name, age)
    this.price = price
    this.setScore = function () {}
}
Student.prototype = Object.create(Person.prototype)//核心代码
Student.prototype.constructor = Student//核心代码
var s1 = new Student('Tom', 20, 15000)
console.log(s1 instanceof Student, s1 instanceof Person) // true true
console.log(s1.constructor) //Student
console.log(s1)
复制代码

一样的，Student继承了全部的Person原型对象的属性和方法。目前来讲，最完美的继承方法！

5. ES6中class 的继承

ES6中引入了class关键字，class能够经过extends关键字实现继承，还能够经过static关键字定义类的静态方法,这比 ES5 的经过修改原型链实现继承，要清晰和方便不少。

ES5 的继承，实质是先创造子类的实例对象this，而后再将父类的方法添加到this上面（Parent.apply(this)）。ES6 的继承机制彻底不一样，实质是先将父类实例对象的属性和方法，加到this上面（因此必须先调用super方法），而后再用子类的构造函数修改this。

须要注意的是，class关键字只是原型的语法糖，JavaScript继承仍然是基于原型实现的。

class Person {
    //调用类的构造方法
    constructor(name, age) {
        this.name = name
        this.age = age
    }
    //定义通常的方法
    showName() {
        console.log("调用父类的方法")
        console.log(this.name, this.age);
    }
}
let p1 = new  Person('kobe', 39)
console.log(p1)
//定义一个子类
class Student extends Person {
    constructor(name, age, salary) {
        super(name, age)//经过super调用父类的构造方法
        this.salary = salary
    }
    showName() {//在子类自身定义方法
        console.log("调用子类的方法")
        console.log(this.name, this.age, this.salary);
    }
}
let s1 = new Student('wade', 38, 1000000000)
console.log(s1)
s1.showName()
复制代码

优势：

• 语法简单易懂,操做更方便

缺点：

• 并非全部的浏览器都支持class关键字

参考连接

• JavaScript常见的六种继承方式
• JavaScript常见的继承方式
• JavaScript深刻之继承的多种方式和优缺点