ES6类继承用extends，super调用父类构造函数

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个文章开发实战，手把手教大家学习《ES6类继承通过extends关键字实现，子类使用super()调用父类构造函数，继承父类方法和属性。》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

super关键字在ES6类继承中用于调用父类的构造函数或方法。1. super()必须在子类构造函数中调用，用于执行父类构造函数并绑定this；2. super.methodName()可调用父类方法，便于扩展其行为；3. this只能在super()后使用，因super()负责初始化父类属性；4. ES5通过原型链和call/apply模拟super()及继承机制；5. 多重继承可通过mixin实现，将多个类的功能组合到一个类中。

ES6的类语法通过extends关键字实现继承，本质上仍然是基于原型链的继承机制。

解决方案

ES6的class语法糖让JavaScript的继承更加清晰和易于理解。它主要依赖extends关键字来声明一个类继承自另一个类，以及super()方法来调用父类的构造函数和方法。

例如：

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name); // 调用父类的构造函数
    this.breed = breed;
  }

  speak() {
    super.speak(); // 调用父类的speak方法
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog('Buddy', 'Golden Retriever');
dog.speak(); // 输出 "Buddy makes a sound." 和 "Buddy barks."

extends关键字建立了Dog类和Animal类之间的继承关系。super()在子类的构造函数中必须调用，它会执行父类的构造函数，并将父类的属性绑定到子类实例上。如果子类定义了与父类同名的方法，可以使用super.methodName()调用父类的方法。

实际上，ES6的类继承仍然是基于原型链的。extends关键字背后，JavaScript引擎会设置子类的__proto__指向父类，子类实例的__proto__指向子类的prototype，而子类的prototype的__proto__则指向父类的prototype。

如何理解ES6类继承中的super关键字？

super关键字在ES6类继承中扮演着至关重要的角色。它不仅仅是一个简单的函数调用，还涉及到this的绑定和构造函数的执行顺序。

1. super()的作用：super()主要用于在子类的构造函数中调用父类的构造函数。必须在子类的constructor中使用super()后，才能使用this关键字。这是因为在JavaScript中，子类必须先完成父类的初始化，才能正确地初始化自身的属性。

2. super.methodName()的作用：super.methodName()用于调用父类的方法。这在子类需要扩展或修改父类方法的行为时非常有用。通过super，子类可以访问父类的方法，并在其基础上添加额外的逻辑。

3. this的绑定：在ES6的类继承中，this的绑定规则比较特殊。在子类的构造函数中，this只有在调用super()之后才能被正确地初始化。super()负责将父类的属性绑定到子类的this上，因此必须先调用super()，才能使用this。

错误示例：

class Animal {
    constructor(name) {
        this.name = name;
    }
}

class Dog extends Animal {
    constructor(name, breed) {
        this.breed = breed; // 错误：必须先调用super()
        super(name);
    }
}

正确示例：

class Animal {
    constructor(name) {
        this.name = name;
    }
}

class Dog extends Animal {
    constructor(name, breed) {
        super(name); // 正确：先调用super()
        this.breed = breed;
    }
}

ES5如何模拟ES6的类继承？

在ES6之前，JavaScript并没有class关键字，因此需要使用原型链来模拟继承。以下是一个简单的ES5模拟ES6类继承的示例：

function Animal(name) {
  this.name = name;
}

Animal.prototype.speak = function() {
  console.log(this.name + ' makes a sound.');
};

function Dog(name, breed) {
  Animal.call(this, name); // 模拟super()
  this.breed = breed;
}

Dog.prototype = Object.create(Animal.prototype); // 设置原型链
Dog.prototype.constructor = Dog; // 修正constructor指向

Dog.prototype.speak = function() {
  Animal.prototype.speak.call(this); // 调用父类方法
  console.log(this.name + ' barks.');
};

var dog = new Dog('Buddy', 'Golden Retriever');
dog.speak(); // 输出 "Buddy makes a sound." 和 "Buddy barks."

这段代码中，Animal.call(this, name)模拟了super()的调用，用于初始化父类的属性。Object.create(Animal.prototype)用于设置Dog的原型链，使其指向Animal的原型。Dog.prototype.constructor = Dog用于修正constructor的指向，确保Dog的实例的constructor属性指向Dog函数。

多重继承在ES6中如何实现？

JavaScript本身并不直接支持多重继承，即一个类继承自多个父类。但可以通过一些技巧来模拟多重继承的效果，例如使用mixin。

Mixin是一种将多个类的功能组合到一个类中的方法。它通过将多个类的属性和方法复制到目标类中来实现。

示例：

const barkable = (Base) => class extends Base {
  bark() {
    console.log('Woof!');
  }
};

const tailWaggable = (Base) => class extends Base {
  wagTail() {
    console.log('Tail wagging!');
  }
};

class Animal {
  constructor(name) {
    this.name = name;
  }
}

class Dog extends barkable(tailWaggable(Animal)) {
  constructor(name) {
    super(name);
  }
}

const dog = new Dog('Buddy');
dog.bark(); // 输出 "Woof!"
dog.wagTail(); // 输出 "Tail wagging!"

在这个例子中，barkable和tailWaggable是两个mixin函数，它们分别向类中添加了bark和wagTail方法。Dog类通过连续调用这两个mixin函数，实现了同时拥有bark和wagTail方法的效果。

到这里，我们也就讲完了《ES6类继承用extends，super调用父类构造函数》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于extends,构造函数,ES6,super,类继承的知识点！