是否可以在 ES6 中扩展类而不调用super调用父类的方法？
编辑：这个问题可能会产生误导。这是我们必须调用的标准super()还是我遗漏了什么？
例如：
class Character {
constructor(){
console.log('invoke character');
}
}
class Hero extends Character{
constructor(){
super(); // exception thrown here when not called
console.log('invoke hero');
}
}
var hero = new Hero();
当我不调用super()派生类时，我遇到了范围问题 ->this is not defined
我在 v2.3.0 中使用 iojs --harmony 运行它
ES2015 (ES6) 类的规则基本上归结为：
this之前不能使用super。super如果ES6 类构造函数是子类，则必须调用它们，否则它们必须显式返回某个对象以代替未初始化的对象。这归结为 ES2015 规范的两个重要部分。
第8.1.1.3.4节定义了决定this函数中内容的逻辑。类的重要部分是它可能this处于某种"uninitialized"状态，当处于这种状态时，尝试使用this会抛出异常。
第9.2.2节，[[Construct]]定义了通过new或调用函数的行为super。调用基类构造函数时，this在第 8 步初始化[[Construct]]，但对于所有其他情况，this未初始化。在构造结束时，GetThisBinding被调用，所以如果super还没有被调用（因此初始化this），或者没有返回显式替换对象，构造函数调用的最后一行将抛出异常。
新的 es6 类语法只是带有原型的“旧”es5“类”的另一种表示法。因此，您不能在不设置其原型（基类）的情况下实例化特定类。
那就像把奶酪放在三明治上而不做。在做三明治之前你也不能放奶酪，所以......
...this在调用超类 with 之前使用关键字super()也是不允许的。
// valid: Add cheese after making the sandwich
class CheeseSandwich extend Sandwich {
constructor() {
super();
this.supplement = "Cheese";
}
}
// invalid: Add cheese before making sandwich
class CheeseSandwich extend Sandwich {
constructor() {
this.supplement = "Cheese";
super();
}
}
// invalid: Add cheese without making sandwich
class CheeseSandwich extend Sandwich {
constructor() {
this.supplement = "Cheese";
}
}
如果没有为基类指定构造函数，则使用以下定义：
constructor() {}
对于派生类，使用以下默认构造函数：
constructor(...args) {
super(...args);
}
编辑：发现这个developer.mozilla.org：
When used in a constructor, the super keyword appears alone and must be used before the this keyword can be used.
有多个答案和评论指出super 必须是里面的第一行constructor。那简直是错误的。@loganfsmyth 回答有要求的必要参考，但归结为：
继承 ( extends) 构造函数必须super在使用this之前和返回之前调用，即使this没有使用
请参阅下面的片段（适用于 Chrome...）以了解为什么this在调用super.
'use strict';
var id = 1;
function idgen() {
return 'ID:' + id++;
}
class Base {
constructor(id) {
this.id = id;
}
toString() { return JSON.stringify(this); }
}
class Derived1 extends Base {
constructor() {
var anID = idgen() + ':Derived1';
super(anID);
this.derivedProp = this.baseProp * 2;
}
}
alert(new Derived1());如果在子类中完全省略构造函数，则可以在子类中省略 super()。“隐藏”的默认构造函数将自动包含在您的子类中。但是，如果您确实在子类中包含构造函数，则必须在该构造函数中调用 super()。
class A{
constructor(){
this.name = 'hello';
}
}
class B extends A{
constructor(){
// console.log(this.name); // ReferenceError
super();
console.log(this.name);
}
}
class C extends B{} // see? no super(). no constructor()
var x = new B; // hello
var y = new C; // hello
阅读本文了解更多信息。
刚刚注册发布此解决方案，因为这里的答案至少不能让我满意，因为实际上有一个简单的方法可以解决这个问题。调整您的类创建模式以覆盖子方法中的逻辑，同时仅使用超级构造函数并将构造函数参数转发给它。
就像在您的子类中本身不创建构造函数一样，而是只引用在相应子类中被覆盖的方法。
这意味着您将自己从强加给您的构造函数功能中解放出来，并避免使用常规方法- 可以覆盖并且不会强制您选择是否、在哪里以及如何调用 super（完全可选）例如：
super.ObjectConstructor(...)
class Observable {
constructor() {
return this.ObjectConstructor(arguments);
}
ObjectConstructor(defaultValue, options) {
this.obj = { type: "Observable" };
console.log("Observable ObjectConstructor called with arguments: ", arguments);
console.log("obj is:", this.obj);
return this.obj;
}
}
class ArrayObservable extends Observable {
ObjectConstructor(defaultValue, options, someMoreOptions) {
this.obj = { type: "ArrayObservable" };
console.log("ArrayObservable ObjectConstructor called with arguments: ", arguments);
console.log("obj is:", this.obj);
return this.obj;
}
}
class DomainObservable extends ArrayObservable {
ObjectConstructor(defaultValue, domainName, options, dependent1, dependent2) {
this.obj = super.ObjectConstructor(defaultValue, options);
console.log("DomainObservable ObjectConstructor called with arguments: ", arguments);
console.log("obj is:", this.obj);
return this.obj;
}
}
var myBasicObservable = new Observable("Basic Value", "Basic Options");
var myArrayObservable = new ArrayObservable("Array Value", "Array Options", "Some More Array Options");
var myDomainObservable = new DomainObservable("Domain Value", "Domain Name", "Domain Options", "Dependency A", "Depenency B");干杯！