Javascript继承

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

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

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.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);
alert(sub1.fun === sub2.fun);   // true

优点：不存在引用属性共享问题，可传参，函数可复用
缺点:（一点小瑕疵）子类原型上有一份多余的父类实例属性，因为父类构造函数被调用了两次，生成了两份，而子类实例上的那一份屏蔽了子类原型上的。。。又是内存浪费，比刚才情况好点，不过确实是瑕疵

4、 寄生式组合继承

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();
alert(sub.val);
alert(sub.arr);