继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//region A
function A(a){
this.a=a
console.log(this.a)
}
A.prototype.AShow=function(){
console.log(this.a+':show')
}
//endregion
//region B
function B(a,b){
A.call(this,a)
this.b='b'
console.log(this.b)
}
// Object.setPrototypeOf( B.prototype, A.prototype )// ES6+,B继承A,修改既存的`B.prototype`
B.prototype=Object.create(A.prototype)// ES5,B继承A,扔掉默认既存的`B.prototype`
Object.defineProperty(B.prototype,'constructor',{// ES5,修复B继承A后丢失的.constructor
enumerable:false,
writable:true,
configurable:true,
value:B// 使‘.constructor’指向‘B’
})
B.prototype.BShow=function(){
console.log(this.b+':show')
}
var b = new B('a','b')
b.AShow()
b.BShow()
//endregion

重要的部分是B.prototype=Object.create(A.prototype)Object.create(..)凭空 创建 了一个“新”对象,并将这个新对象内部的[[Prototype]]链接到你指定的对象上(在这里是A.prototype)。

换句话说,这一行的意思是:“做一个 新的 链接到 ‘A.prototype’ 的 ‘B.prototype’ 对象”。

“(原型)继承”

类继承

1
2
3
4
5
6
7
8
9
10
11
12
unction SuperClass(){
this.superValue = true;
}
SuperClass.prototype.getSuperValue = function(){return this.superValue;}
function SubClass(){
this.subValue = true;
}
SubClass.prototype = new SuperClass()//继承父类
SubClass.prototype.getSubValue = function(){return this.subValue;}
//console.log(SubClass.prototype instanceof SuperClass)//=>true

构造函数继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function SuperClass(value){
this.superValue = value;
}
SuperClass.prototype.getSuperValue = function(){return this.superValue;}
function SubClass(value){
SuperClass.call(this, value);//继承父类
this.subValue = value;
}
SubClass.prototype.getSubValue = function(){return this.subValue;}
// var instance = new SubClass(10);
// console.log(instance.superValue);//=>10
// console.log(instance.getSubValue());//=>10
// console.log(instance.getSuperValue());//=>'TypeError'

组合继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function SuperClass(value){
this.superValue = value;
}
SuperClass.prototype.getSuperValue = function(){return this.superValue;}
function SubClass(value){
SuperClass.call(this, value);//构造函数继承父类的 superValue
this.subValue = value;
}
SubClass.prototype = new SuperClass();//类继承父类原型 getSuperValue
SubClass.prototype.getSubValue = function(){return this.subValue;}
// var instance = new SubClass(10);
// console.log(instance.superValue);//=>10
// console.log(instance.getSubValue());//=>10
// console.log(instance.getSuperValue());//=>10

原型继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function inheriteObject(o){
//声明过渡函数对象
function F(){}
//过渡函数对象的原型继承父对象
F.prototype = o;
//返回过渡对象的一个实例,这个实例继承了父对象
return new F();
}
// var superObject = {
// name: 'books',
// books:['css','javascript']
// }
// var newSubObject = inheriteObject(superObject);
// console.log(newSubObject.name);//=>'books'
// newSubObject.books.push('html');
// console.log(newSubObject.books);//=>['css','javascript','html']

寄生式继承

1
2
3
4
5
6
7
8
9
10
11
var superObject = {
name: 'books',
books:['css','javascript']
}
function creatBook(obj){
var o = inheriteObject(obj);
o.getBooks = function(){
console.log(name)
}
return o;
}

寄生组合式继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/**
* 寄生组合式继承
* @param subClass 子类
* @param superClass 父类
*/
function inheritePrototype(subClass,superClass){
//复制父类的原型
var p = inheriteObject(superClass.prototype);
//修正因为重写父类原型导致子类 constructor 属性被修改
p.constructor = subClass;
//设置子类的原型
subClass.prototype = p;
}
// //定义父类
// function SuperClass(value){
// this.superValue = value;//父类属性
// }
// //定义父类原型方法
// SuperClass.prototype.getSuperValue = function(){
// console.log(this.superValue);
// }
// //定义子类
// function SubClass(value){
// SuperClass.call(this, value);//构造函数继承
// this.subValue = value;//子类属性
// }
// inheritePrototype(SubClass, SuperClass);//寄生式继承父类原型
// //子类增加原型方法
// SubClass.prototype.getSubValue = function(){
// console.log(this.subValue);
// }
// var instance = new SubClass(10);
// console.log(instance.superValue);//=>10
// console.log(instance.subValue);//=>10
// instance.getSuperValue();//=>10
// instance.getSubValue();//=>10
坚持原创技术分享,您的支持将鼓励我继续创作!