继承是为了子类可以使用父类的所有功能,并且能对这些功能进行扩展。
1. 构造函数继承(call&apply)
说明:直接利用call或者apply方法将父类构造函数的this绑定为子类构造函数的this就可以;
缺点:无法继承原型链上的属性与方法;
function Parent1() {
this.name = 'parent1'
}
Parent1.prototype.say = function () {
console.log(this.name)
}
function Child1() {
Parent1.call(this) //构造函数继承核心代码
this.type = 'child1'
}
let child1_1 = new Child1()
console.log(child1_1.name) // parent1
console.log(child1_1.say()) // child1_1.say is not a function
复制代码
2. 原型继承
说明:将子类的原型挂载到父类上;
缺点:子类new出来的实例,父类的属性没有隔离,会相互影响;
function Parent2() {
this.name = 'parent2'
this.arr = [1, 2, 3]
}
Parent2.prototype.say = function () {
console.log(this.name)
}
function Child2() {
this.type = 'child2'
}
Child2.prototype = new Parent2() //原型继承核心代码
let child2_1 = new Child2()
let child2_2 = new Child2()
console.log(child2_1.name) // parent2
console.log(child2_1.say()) // parent2
child2_1.arr.push(4)
console.log(child2_1.arr, child2_2.arr) // [1, 2, 3, 4] [1, 2, 3, 4]
复制代码
3. 组合继承
说明:组合上面的构造函数与原型继承的功能;
缺点:call()方法已经拿到父类所有的属性 ,后面再使用原型时也会有父类所有属性;
function Parent3() {
this.name = 'parent3'
this.arr = [1, 2, 3]
}
Parent3.prototype.say = function () {
console.log(this.name)
}
function Child3() {
Parent3.call(this)
this.type = 'child3'
}
Child3.prototype = new Parent3()
let child3_1 = new Child3()
let child3_2 = new Child3()
child3_1.arr.push(4)
console.log(child3_1.arr, child3_2.arr) // [1, 2, 3, 4] [1, 2, 3]
// 缺点是 Parent3执行了两次,child3中有重复属性
复制代码
4. 寄生组合继承
说明:解决组合继承重复属性的问题,直接将子类的原型等于父类的原型,或者是用Object.create继承原型但不执行父类构造函数;
注意处理子类实例的 constructor 指向问题,new Parent2()也有这个问题;
function Parent4() {
this.name = 'parent4'
this.arr = [1, 2, 3]
}
Parent4.prototype.say = function () {
console.log(this.name)
}
function Child4() {
Parent4.call(this)
this.type = 'child4'
}
//子类的原型等于父类的原型
Child4.prototype = Parent4.prototype
//或 Child4.prototype = Object.create(Parent4.prototype)
//修复重写子类原型导致子类constructor属性被修改
Child4.prototype.constructor = Child4
let child4_1 = new Child4()
let child4_2 = new Child4()
child4_1.arr.push(4)
console.log(child4_1.arr, child4_2.arr) // [1, 2, 3, 4] [1, 2, 3]
console.log(child4_1.constructor === Child4) // true
console.log(child4_1.constructor === Parent4)// false
// 这里的Child4就是一个继承自Function的函数对象
console.log(Child4.constructor === Parent4) // false
复制代码
5. Class继承
说明:ES6新增,class是一个语法糖,就是基于寄生组合继承来实现的;
class Parent5{
constructor(){
this.name = 'Parent5'
this.arr = [1, 2, 3]
}
say(){
console.log(this.name)
}
}
class Child5 extends Parent5{
constructor(){
super() //通过super()调用父类构造函数
this.type="Child5"
}
}
let child5_1 = new Child5()
let child5_2 = new Child5()
child5_1.arr.push(4)
console.log(child5_1.say()) // Parent5
console.log(child5_1.arr, child5_2.arr) // [1, 2, 3, 4] [1, 2, 3]
console.log(child5_1.constructor === Child5) // true
console.log(child5_2.constructor === Parent5) // false
复制代码
1.ES6里Class的Extends继承原理
寄生组合式继承原理:
1.使用借用构造函数(call)来继承父类this声明的属性/方法
2.通过寄生式封装函数设置父类prototype为子类prototype的原型来继承父类的prototype声明的属性/方法
2. 《你不知道的JS》上卷 A.1
class 很好地伪装成 JavaScript 中类和继承设计模式的解决方案,但是它实际上起到了反作用:它隐藏了许多问题并且带来了更多更细小但是危险的问题。
es6继承
代码量少,易懂
//class 相当于es5中构造函数
//class中定义方法时,前后不能加function,全部定义在class的protopyte属性中
//class中定义的所有方法是不可枚举的
//class中只能定义方法,不能定义对象,变量等
//class和方法内默认都是严格模式
//es5中constructor为隐式属性
class People{
constructor(name='wang',age='27'){
this.name = name;
this.age = age;
}
eat(){
console.log(`${this.name} ${this.age} eat food`)
}
}
//继承父类
class Woman extends People{
constructor(name = 'ren',age = '27'){
//继承父类属性
super(name, age);
}
eat(){
//继承父类方法
super.eat()
}
}
let wonmanObj=new Woman('xiaoxiami');
wonmanObj.eat();
ES5继承和ES6继承的区别
es5继承首先是在子类中创建自己的this指向,最后将方法添加到this中
Child.prototype=new Parent() || Parent.apply(this) || Parent.call(this)
es6继承是使用关键字先创建父类的实例对象this,最后在子类class中修改this
补充:constructor的作用
constructor属性不影响任何JavaScript的内部属性。instanceof检测对象的原型链,通常你是无法修改的(不过某些引擎通过私有的__proto__属性暴露出来)。
constructor其实没有什么用处,只是JavaScript语言设计的历史遗留物。由于constructor属性是可以变更的,所以未必真的指向对象的构造函数,只是一个提示。不过,从编程习惯上,我们应该尽量让对象的constructor指向其构造函数,以维持这个惯例。
补充:new与Object.create()区别
- new创建一个对象,执行构造函数。
- Object.create相当于创建一个对象,但是不执行构造函数。
function Parent(){
this.name="Parent"
}
Parent.prototype.age = '18'
let child_new = new Parent()
let child_create = Object.create(Parent.prototype)
console.log(child_new instanceof Parent) // true
console.log(child_create instanceof Parent) // true
console.log(child_new.name,child_new.age) // Parent 18
console.log(child_create.name,child_create.age) // undefined "18"
//简单模拟下 Object.create 如下:
function create(obj) {
let F = function () {}
F.prototype = obj
return new F()
}