javascript实现继承

//约定:下面将展开一个有点长的故事，所以有必要提前约定共同语言：
/*
 * 约定
 */
function Fun(){
    // 私有属性
    var val = 1;        // 私有基本属性
    var arr = [1];      // 私有引用属性
    function fun(){}    // 私有函数（引用属性）

    // 实例属性
    this.val = 1;               // 实例基本属性
    this.arr = [1];             // 实例引用属性
    this.fun = function(){};    // 实例函数（引用属性）
}

// 原型属性
Fun.prototype.val = 1;              // 原型基本属性
Fun.prototype.arr = [1];            // 原型引用属性
Fun.prototype.fun = function(){};   // 原型函数（引用属性）

console.log("--------------------");

/**
 * 一.简单原型链
 *
 * 3.优缺点

 优点：
 简单，易于实现
 缺点：
 修改sub1.arr后sub2.arr也变了，因为来自原型对象的引用属性是所有实例共享的。

 可以这样理解：执行sub1.arr.push(2);先对sub1进行属性查找，找遍了实例属性（在本例中没有实例属性），没找到，就开始顺着原型链向上找，拿到了sub1的原型对象，一搜身，发现有arr属性。于是给arr末尾插入了2，所以sub2.arr也变了

 创建子类实例时，无法向父类构造函数传参
 */
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);
console.log(sub1.val);    // 2
console.log(sub2.val);    // 1

console.log(sub1.arr);    // 1, 2
console.log(sub2.arr);    // 1, 2
console.log(Sub.constructor, Sub.prototype.constructor); //[Function: Function] [Function: Super]

console.log("--------------------");

/**
 * 二.借用构造函数
 *
 * 3.优缺点

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

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

 P.S.前辈就这么高效，两个缺陷瞬间修复
 缺点：
 无法实现函数复用，每个子类实例都持有一个新的fun函数，太多了就会影响性能，内存爆炸。。
 P.S.好吧，刚修复了共享引用属性的问题，又出现了这个新问题。。
 *
 */
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);
console.log(sub1.val);    // 1
console.log(sub2.val);    // 2

console.log(sub1.arr);    // 1, 2
console.log(sub2.arr);    // 1

console.log(sub1.fun === sub2.fun);   // false

console.log("--------------------");

/**
 * 三.组合继承（最常用）
 *
 *3.优缺点

 优点：
 不存在引用属性共享问题
 可传参
 函数可复用
 缺点:
 （一点小瑕疵）子类原型上有一份多余的父类实例属性，因为父类构造函数被调用了两次，生成了两份，而子类实例上的那一份屏蔽了子类原型上的。。。又是内存浪费，比刚才情况好点，不过确实是瑕疵
 */
function Super(){
    // 只在此处声明基本属性和引用属性
    this.val = 1;
    this.arr = [1];
}
//  在此处声明函数
Super.prototype.fun1 = function(){};
Super.prototype.fun2 = function(){};
//Super.prototype.fun3...
function Sub(){
    Super.call(this);   // 核心
    // ...
}
Sub.prototype = new Super();    // 核心

var sub1 = new Sub(1);
var sub2 = new Sub(2);
console.log(sub1.fun === sub2.fun);   // true
console.log(Sub.prototype.constructor); //[Function: Super]

console.log("--------------------");

/**
 * 四.寄生组合继承（最佳方式）
 *
 * 3.优缺点

 优点：完美了
 缺点：理论上没有了（如果用起来麻烦不算缺点的话。。）
 P.S.用起来麻烦是一方面，另一方面是因为寄生组合式继承出现的比较晚，是21世纪初的东西，大家等不起这么久，所以组合继承是最常用的，而这个理论上完美的方案却只是课本上的最佳方式了
 */
function beget(obj){   // 生孩子函数 beget：龙beget龙，凤beget凤。
    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();
console.log(sub.val);
console.log(sub.arr);
console.log("--------------------");