都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里创建不必要的属性，与此同时原型链也保持不变，公认是最理想的继承模式
