共有六种：原型链继承、借用构造函数继承、组合继承、原型式继承、寄生式继承、寄生组合继承。

父类

// 父类
function Person(name){//构造函数
  this.name = name;
  this.sum = function(){
    console.log(this.name)
  }
}
Person.prototype.age = 10;

原型链继承

重点：父类实例赋值给新实例的原型

特点：

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

缺点：

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

/ 原型链继承
function Per(){
    this.name = "ker";
}

Per.prototype = new Person();//重点
var per1 = new Per();
console.log('原型链继承', per1 instanceof Person);//true

借用构造函数继承

重点：用call或apply方法将父类构造函数引入子类函数（在子类函数中做了父类函数的自执行（复制））

特点：

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

缺点：

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

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

组合继承（常用）

原型链继承+借用构造函数继承

重点：结合了前两种继承的优点：传递参数和复用

特点：

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

缺点：调用了两次父类构造函数，消耗内存，子类构造函数会代替原型上的父类构造函数

function SubType(name){
    Person.call(this, name);//借用构造函数继承
}
SubType.prototype = new Person();//原型链继承
var sub = new SubType("gar");
console.log(sub.name);//"gar" 继承了构造函数属性name
console.log(sub.age);//10 继承了父类原型的属性age

原型式继承

重点：用一个函数包装一个对象，然后返回这个函数的调用，这个函数就变成可以随意增添的实例或对象。Object.create()就是这个原理。

Object.create() 方法创建一个新对象，使用现有的对象来提供新创建的对象的__proto__。

特点：类似复制一个对象，用函数来包装

缺点：

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

function content(obj){
    function F(){}
    F.prototype = obj;//继承了传入的参数
    return new F();//返回函数对象
}

var sup = new Person();//拿到父类的实例
var sup1 = content(sup);
console.log(sup1.age);//10 继承了父类函数的属性

寄生式继承

重点：给原型式继承外面套个壳子

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

缺点：没用到原型，无法复用

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

寄生组合式继承（常用）

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

组合：

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

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

// 寄生
function content(obj){
    function F(){}
    F.prototype = obj;
    return new F();
}
// content就是F实例的另一种表示法
var con = content(Person.prototype);
// con实例（F实例）的原型继承了父类函数的原型

// 组合
function Sub(){
    Person.call(this);//这个继承了父类构造函数的属性
}//解决了组合式两次调用构造函数属性 缺点
// 重点
Sub.prototype = con;//继承了con实例
con.constructor = Sub;//一定要修复实例
var sub1 = new Sub();
// Sub的实例就继承了构造函数属性，父类实例，con的函数属性
console.log(sub1.age);//10

JavaScript之继承