JavaScript——实现继承的几种方式
实现继承的6中方法:
- 借用构造函数
- 组合继承
- 原型式继承
- 寄生式继承
- 寄生组合式继承
- 拷贝继承
1. 借用构造函数
在子类型构造函数的内部调用超类构造函数。通过使用apply()和call()方法在新创建的对象上执行构造函数
可以在子类型构造函数中向超类型构造函数传递参数
缺点:只能继承超类型的实例属性,对于原型上的方法和属性无法继承。
function SuperType(name) {
this.name = name;
this.colors = ['red','blue','green']
}
function SubType() {
// 继承SuperType
SuperType.call(this,'ronghui');
this.age = 19;
}
var instance1 = new SubType();
instance1.colors.push('black');
console.log(instance1.colors) // ["red", "blue", "green", "black"]
console.log(instance.name) // ronghui
console.log(instance.age) // 19
2. 组合继承
组合继承也叫伪经典继承,指的是将原型链和急用构造函数的技术组合到一块,从而发挥二者之长的一种继承模式。其背后的思路是使用原型链实现对原型属性和方法的继承,而通过借用构造函数来实现对实例属性的的继承。这样,既通过原型上定义方法实现了函数复用,又能够保证每个实例都有它自己的属性。
缺点:
- 无论在什么情况下,都会调用两次超类型构造函数
- 一次是在创建子类型原型的时候,另一次是在子类型构造函数内部,子类型会继承超类型对象的全部实例属性;
- 这些实例属性可能不是我们想要的,因为我们还需要定义自己私有的属性,
function SuperType(name) {
this.name = name;
this.colors = ['red', 'blue', 'green'];
}
SuperType.prototype.sayName = function () { console.log(this.name) }
function SubType(name, age) {
// 继承属性
SuperType.call(this, name);
this.age = age;
}
// 继承方法
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function () { console.log(this.age) }
var instance1 = new SubType('张三', 29);
instance1.colors.push('block')
console.log(instance1.colors) // ["red", "blue", "green", "block"]
instance1.sayName() // 张三
instance1.sayAge() // 29
var instance2 = new SubType('李四', 24);
console.log(instance2.colors); // ["red", "blue", "green"]
instance2.sayName() // 李四
instance2.sayAge() // 24
3. 原型式继承
function object(o) {
function F()
F.prototype = o;
return new F()
}
var person = {
name: '张三',
f
}
ES5的Object.create()实现原型式继承,接受两个参数:一个用做新对象原型的对象和一个为新对象定义额外属性的对象。
var person = {
name: 'Nicholas',
friends: ['Shelby', 'Court', 'Van']
}
var anotherPerson = Object.create(person);
anotherPerson.name = 'Greg';
anotherPerson.friends.push('Rob');
var yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = 'Linda';
yetAnotherPerson.friends.push('Barbie');
console.log(person.friends); // ["Shelby", "Court", "Van", "Rob", "Barbie"]
4. 寄生式继承
function createAnother(original) {
let clone = Object.create(original);
clone.sayHi = function() { console.log( 'hi')}
return clone
}
5. 寄生组合式继承
组合继承缺点:无论在什么情况下,都会调用两次超类型构造函数:一次是在创建子类型原型的时候,另一次是在子类型构造函数颞部。
寄生组合继承,是通过借用构造函数来继承属性,通过原型链的混成形式来继承方法
function inheritPrototype(subType, superType) {
var prototype = Object.create(superType.prototype);
prototype.constructor = subType;
subType.prototype = prototype;;
}
function SuperType(name) {
this.name = name;
this.colors = ['red', 'blue', 'green']
}
SuperType.prototype.sayName = function () {
console.log(this.name)
}
function SubType(name, age) {
SuperType.call(this, name);
this.age = age;
}
inheritPrototype(SubType, SuperType);
SubType.prototype.sayAge = function () {
console.log(this.age)
}
var instance1 = new SubType('张三', 18)
instance1.sayName() // 张三
instance1.sayAge(); // 18
6. 拷贝继承
for...in遍历原型
function Animal() { }
Animal.prototype.species = '动物';
function extends2(SubType, SupType) {
var p = SupType.prototype;
var c = SubType.prototype;
for (var i in p) {
c[i] = p[i]
}
}
extends2(Cat, Animal);
var cat1 = new Cat('大毛', '黄色')
console.log(cat1.species)