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, arguments); // 核心
// ...
}
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,因为sub1和sub2各自拥有fun,它们的内存地址是不同的
优点:
1.解决了子类实例共享父类引用属性的问题
2.创建子类实例时,可以向父类构造函数传参
缺点:
1.无法实现函数复用,每个子类实例都持有一个新的fun函数,如果实例太多,会造成内存大量被占用
2.父类prototype里的东西不能获取到
3、
function Parent (value) {
this.value = value
this.arr = ['one']
}
Parent.prototype.fun = function () {
return 'smile'
}
function Sub(value){
Parent.call(this,value)
}
Sub.prototype = new Parent()
var sub1 = new Sub(1)
var sub2 = new Sub(2)
console.log(sub1.value) //1
console.log(sub2.value) //2
console.log(sub1.fun == sub2.fun) //true
说明:
1.把实例函数都放在原型对象上,以实现函数复用。同时还要保留借用构造函数方式的优点,通过Parent.call(this,value)继承父类的基本属性和引用属性并保留能传参的优点;通过Sub.prototype = new Parent()继承父类函数,实现函数复用;
2.优点:
不存在引用属性共享问题;
可传参;
函数可复用;
3.缺点
子类原型上有一份多余的父类实例属性,因为父类构造函数被调用了两次,生成了两份,而子类实例上的那一份屏蔽了子类原型上的。。。又造成了内存浪费:
例如:console.log(sub1)