JavaScript 继承的几种方式及优缺点

都9012了，使用ES6语法糖的Class继承

class Person {
}

class Child extends Person {
}

简单易用，详细说明请参考 http://es6.ruanyifeng.com/#docs/class-extends

但本文要理清的是ES6之前的继承方式：

1、原型链

function Person () {
  this.age = 18
  this.friends = ['Denise', 'Hins']
}
Person.prototype.getAge = function () {
  return this.age
}

function Child () {
  this.property = true
}
Child.prototype = new Person()
// Child.prototype.constructor = Child

var instance1 = new Child()
var instance2 = new Child()

console.log(instance1.getAge()) // 18 父类的方法
console.log(instance1.property) // true 自己的属性

instance1.friends.push('Wyman')
console.log(instance2.friends) // ['Denise', 'Hins', 'Wyman'] 引用类型是共享的

instance2.age = 21
console.log(instance1.age) // 18 基本类型是独立的

console.log(instance1.constructor) // Person 实例的 constructor 应该指向它的构造函数，instance1的构造函数是Child

Child.prototype.constructor = Child // 手动修正constructor指向，此行应放在上述注释处
console.log(instance1.constructor) // Child

因为会共享原型的引用类型属性，现实中很少单独使用

2、借用构造函数

function Person (name) {
  this.name = name
  this.friends = ['Denise', 'Hins']
}

function Child () {
  Person.call(this, 'Joey')
  this.age = 19
}

var instance1 = new Child()
var instance2 = new Child()

console.log(instance1.name) // Joey
console.log(instance1.friends) // ['Denise', 'Hins']
console.log(instance1.age) // 19

instance1.friends.push('wyman')

console.log(instance2.friends) // ['Denise', 'Hins']

Person.prototype.getName = function () { // 在构造函数的原型上添加一个方法
  return this.name
}
console.log(instance1.getName()) // 报错！！！

1、可以传参到构造函数Person
2、解决了构造函数引用类型属性共享问题
3、在构造函数Person上添加一个方法，实例是没办法使用的，只能把方法都写在Person里面，但这样就没办法函数复用了，没有了继承的意义
现实中也很少单独使用

3、组合继承

function Person (name) {
  this.name = name
  this.friends = ['Denise', 'Hins']
}
Person.prototype.getName = function () {
  return this.name
}
function Child (name, age) {
  Person.call(this, name)  // 第二次调用父类
  this.age = age
}
Child.prototype = new Person()  // 第一次调用父类
Child.prototype.constructor = Child
Child.prototype.getAge = function () {
  return this.age
}
var instance1 = new Child('Joey', 19)
var instance2 = new Child('Hocc', 21)

instance1.friends.push('wyman')
console.log(instance1.friends) // ['Denise', 'Hins', 'wyman']
console.log(instance2.friends) // ['Denise', 'Hins']

console.log(instance1.getName()) // Joey
console.log(instance2.getName()) // Hocc

console.log(instance1.getAge()) // 19
console.log(instance2.getAge()) // 21

集原型链和借用构造函数方式之长，避开二者的缺点，是常用的一种继承模式，
但继承的时候会调用两次父类，会产生两组name和friends属性，一组在Child中，一组在实例中，所以也不是完美的

4、原型式继承

var person = {
  name: 'Nicole',
  friends: ['Hocc', 'Joey']
}

var instance1 = Object.create(person)
var instance2 = Object.create(person)

instance1.friends.push('wyman')
console.log(instance2.friends) // ["Hocc", "Joey", "wyman"]

利用 Object.create 生成一个新的对象，免去了创造一个构造函数，但引用类型属性是共享的

5、寄生式继承

function object (o) {
  function F () { }
  F.prototype = o
  return new F()
}
function createPerson (p) {
  var o = object(p)
  o.sayHi = function () {
    console.log('hi')
  }
  return o
}
var person = {
  name: 'Nicole',
  friends: ['Hocc', 'Joey']
}
var p = createPerson(person)
p.sayHi() // hi

不能做到函数复用，单独使用没有实际意义

6、组合寄生继承

function object (o) {
  function F () { }
  F.prototype = o
  return new F()
}
function inheritPrototype = function (c, p) {
  var prototype = object(p.prototype)
  protytype.constructor = c
  c.prototype = prototype
}
function Person (name) {
  this.name = name
  this.friends = ['Denise', 'Hins']
}
Person.prototype.getName = function () {
  return this.name
}
function Child (name, age) {
  Person.call(this, name)  // 第二次调用父类
  this.age = age
}
inheritPrototype(Child, Person) // 代替组合继承中的 Child.prototype = new Person()

只调用了Person一次，免去了Child里创建不必要的属性，与此同时原型链也保持不变，公认是最理想的继承模式