在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
我正在使用iojs v2.3.0中的--harmony运行此代码
ES2015（ES6）类的规则基本上可以归结为：
super之后才能使用this。super，或者它们必须显式返回某个对象来代替未初始化的对象。这归结为ES2015规范的两个重要部分。
第8.1.1.3.4节定义了在函数中决定this是什么的逻辑。对于类来说重要的部分是它可能处于"uninitialized"状态，当处于此状态时，尝试使用this会抛出异常。
第9.2.2节[[Construct]]定义了通过new或super调用函数的行为。调用基本类构造函数时，this初始化为[[Construct]]的第8步，但对于所有其他情况，this未初始化。在构造完成后，会调用GetThisBinding，因此如果尚未调用super（从而初始化了this），或者没有显式返回替换对象，则构造函数调用的最后一行将抛出异常。
super() 的情况下继承一个类的方法？ - Bergisuper() 的情况下从一个类继承？ - Bergireturn Object.create(new.target.prototype, …)来避免调用超级构造函数，这样做会使内容更加易懂。 - Bergi新的ES6类语法只是使用原型的“旧”ES5“类”的另一种表示方法。因此，如果不设置它的原型（即基类），则无法实例化特定类。
这就像在三明治上放奶酪而没有做它一样。同样，您也不能在制作三明治之前放置奶酪，所以...
...在使用super（）调用超类之前使用this关键字也是不允许的。
// 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上找到了这个：
当在构造函数中使用时，super关键字单独出现，并且必须在使用this关键字之前使用。
this。this，即使该函数可能或可能不定义补充属性。this 了吗？！this。我只是想用一个比喻来解释 es6 类，没有人需要这样具有破坏性和不必要的评论。有多个答案和评论声称，在constructor中，super MUST是第一行。这是完全错误的。@loganfsmyth的回答提供了必要的要求参考，但归根结底是：
继承（extends）构造函数必须在使用this之前，并在返回之前调用super，即使没有使用this
查看下面的片段（在Chrome中工作……），以了解为什么在调用super之前可能有没有使用this的语句。
'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()之前在构造函数中使用方法，但是不能在类中使用方法！ - marcelsuper() 之前使用 this（你的代码可以证明这一点），这与规范无关，而是与 JavaScript 的实现有关。因此，你必须在调用 'this' 之前先调用 'super'。 - marcelsuper之前只陈述语句是合法的，而你则声称在调用super之前使用this是非法的。我们都是正确的，只是彼此没有理解 :-) （那个异常是故意的，以展示什么是不合法的 - 我甚至将属性命名为“WillFail”） - Amitsuper不一定要是第一个语句。但是我为什么想要那样做呢？在调用基础构造函数之前生成一个id？为什么不对所有类都使用它？derivedProp是null。它至少引出了很多问题。而且你让它听起来像你有一个实际应用的例子。但这个例子仍然是理论的。 - x-yuri如果在子类中完全省略构造函数，则可以在子类中省略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
查看此页面了解更多信息。
justyourimage提供的答案是最简单的方法，但他的示例有些冗长。这里是通用版本：
class Base {
constructor(){
return this._constructor(...arguments);
}
_constructor(){
// just use this as the constructor, no super() restrictions
}
}
class Ext extends Base {
_constructor(){ // _constructor is automatically called, like the real constructor
this.is = "easy"; // no need to call super();
}
}
constructor()，只需使用虚假的_constructor()来进行实例化逻辑。也就是说，在您的子类中不会创建构造函数，而只会引用在相应子类中被覆盖的方法。
这意味着您可以摆脱强制执行的构造函数功能，并退回到常规方法 - 可以被覆盖，并且不会强制执行super()让您自由选择是否，何时以及如何调用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");干杯！
@Bergi提到了new.target.prototype，但我正在寻找一个具体的示例来证明您可以访问this（或者更好的是，客户端代码正在使用new创建对象的引用，请参见下文）而无需调用super()。
空谈误国，展示代码......所以这里有一个例子：
class A { // Parent
constructor() {
this.a = 123;
}
parentMethod() {
console.log("parentMethod()");
}
}
class B extends A { // Child
constructor() {
var obj = Object.create(new.target.prototype)
// You can interact with obj, which is effectively your `this` here, before returning
// it to the caller.
return obj;
}
childMethod(obj) {
console.log('childMethod()');
console.log('this === obj ?', this === obj)
console.log('obj instanceof A ?', obj instanceof A);
console.log('obj instanceof B ?', obj instanceof B);
}
}
b = new B()
b.parentMethod()
b.childMethod(b)
这将输出：
parentMethod()
childMethod()
this === obj ? true
obj instanceof A ? true
obj instanceof B ? true
B（子类）的对象，该对象也是A（其父类）的对象，并且在子类B的childMethod()中，我们使用this指向在B的constructor中使用Object.create(new.target.prototype)创建的对象obj。super。new构造新实例时，constructor可以返回完全不同的对象。尝试：
class Character {
constructor(){
if(Object.getPrototypeOf(this) === Character.prototype){
console.log('invoke character');
}
}
}
class Hero extends Character{
constructor(){
super(); // throws exception when not called
console.log('invoke hero');
}
}
var hero = new Hero();
console.log('now let\'s invoke Character');
var char = new Character();
OODK(function($, _){
var Character = $.class(function ($, µ, _){
$.public(function __initialize(){
$.log('invoke character');
});
});
var Hero = $.extends(Character).class(function ($, µ, _){
$.public(function __initialize(){
$.super.__initialize();
$.log('invoke hero');
});
});
var hero = $.new(Hero);
});
class ParentClass() {
constructor(skipConstructor = false) { // default value is false
if(skipConstructor) return;
// code here only gets executed when 'super()' is called with false
}
}
class SubClass extends ParentClass {
constructor() {
super(true) // true for skipping ParentClass's constructor.
// code
}
}