继承方式

1.简单原型链

function Super(){
    this.val = 1;
    this.arr = [1];
}
function Sub(){
// ...
}
Sub.prototype = new Super();    // 核心

var sub1 = new Sub();
var sub2 = new Sub();
sub1.val = 2;
sub1.arr.push(2);
alert(sub1.val);    // 2
alert(sub2.val);    // 1

alert(sub1.arr);    // 1, 2
alert(sub2.arr);    // 1, 2

优点：简单，易于实现
缺点：

1. 修改sub1.arr后sub2.arr也变了，因为来自原型对象的引用属性是所有实例共享的。
   可以这样理解：执行sub1.arr.push(2);先对sub1进行属性查找，找遍了实例属性（在本例中没有实例属性），没找到，就开始顺着原型链向上找，拿到了sub1的原型对象，一搜身，发现有arr属性。于是给arr末尾插入了2，所以sub2.arr也变了
2. 创建子类实例时，无法向父类构造函数传参

2.借用构造函数

function Super(val){
    this.val = val;
    this.arr = [1];

    this.fun = function(){
    // ...
    }
}
function Sub(val){
    Super.call(this, val);   // 核心
// ...
}

var sub1 = new Sub(1);
var sub2 = new Sub(2);
sub1.arr.push(2);
alert(sub1.val);    // 1
alert(sub2.val);    // 2

alert(sub1.arr);    // 1, 2
alert(sub2.arr);    // 1

alert(sub1.fun === sub2.fun);   // false

优点：

• 解决了子类实例共享父类引用属性的问题

• 创建子类实例时，可以向父类构造函数传参

缺点：

• 无法实现函数复用，每个子类实例都持有一个新的fun函数，太多了就会影响性能，内存爆炸。。

3.组合继承（最常用）

function Super(){
    // 只在此处声明基本属性和引用属性
    this.val = 1;
    this.arr = [1];
}
//  在此处声明函数
Super.prototype.fun = function(){};
function Sub(){
    Super.call(this);   // 核心
    // ...
}
Sub.prototype = new Super();    // 核心

var sub1 = new Sub(1);
var sub2 = new Sub(2);
alert(sub1.fun === sub2.fun);   // true

优点：把实例函数都放在原型对象上，以实现函数复用。同时还要保留借用构造函数方式的优点。
缺点：子类原型上有一份多余的父类实例属性，因为父类构造函数被调用了两次，生成了两份，而子类实例上的那一份屏蔽了子类原型上的。

4.寄生组合继承（最佳方式）

function beget(obj){   
    var F = function(){};
    F.prototype = obj;
    return new F();
}
function Super(){
    // 只在此处声明基本属性和引用属性
    this.val = 1;
    this.arr = [1];
}
//  在此处声明函数
Super.prototype.fun1 = function(){};
Super.prototype.fun2 = function(){};
//Super.prototype.fun3...
function Sub(){
    Super.call(this);   // 核心
    // ...
}
var proto = beget(Super.prototype); // 核心
proto.constructor = Sub;            // 核心
Sub.prototype = proto;              // 核心

var sub = new Sub();
alert(sub.val);
alert(sub.arr);

优点：切掉了原型对象上多余的那份父类实例属性。
缺点：出来写起来麻烦一点，没啥毛病！

5.原型式和6.寄生式就是寄生组合继承的一种过度关系，不详细说明了。

具体详解可见参考资料：

• JavaScript高级程序设计》
• JavaScript语言精粹
• Javascript 面向对象编程-阮一峰大神
• 重新理解JS的6种继承方式