ES6でスーパーを使用せずにクラスを拡張する方法は？

super親クラスを呼び出すメソッドを呼び出さずにES6でクラスを拡張することは可能ですか？

編集：質問は誤解を招く可能性があります。私たちが呼び出さなければならないのは標準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 --harmony with v2.3.0で実行しています

ES2015（ES6）クラスのルールは基本的に次のようになります。

1. 子クラスのコンストラクタでthisは、superが呼び出されるまで使用できません。
2. ES6クラスコンストラクターsuperは、サブクラスの場合は呼び出す必要があります。そうでない場合は、初期化されなかったオブジェクトの代わりにオブジェクトを明示的に返す必要があります。

これは、ES2015仕様の2つの重要なセクションに分類されます。

セクション8.1.1.3.4ではthis、関数の内容を決定するロジックを定義しています。クラスの重要な部分thisは、"uninitialized"状態になる可能性があり、この状態のときに使用しようとするthisと例外がスローされることです。

セクション9.2.2、[[Construct]]経由で呼び出される関数の振る舞いを定義し、newまたはをsuper。基本クラスのコンストラクターを呼び出すと、thisはステップ＃8で初期化されます[[Construct]]が、それ以外の場合thisは初期化されません。構築の最後にGetThisBindingが呼び出されるため、superまだ呼び出されていない（つまり初期化中this）場合、または明示的な置換オブジェクトが返されなかった場合は、コンストラクター呼び出しの最後の行で例外がスローされます。

内部の最初の行でsuper なければならないことを示す複数の回答とコメントがありましたconstructor。それは単に間違っています。@loganfsmyth回答には、必要な要件のリファレンスがありますが、要約すると次のようになります。

継承（extends）コンストラクタは、使用されていない場合でも、使用する前と戻る前に呼び出す必要がありますsuperthisthis

をthis呼び出す前にステートメントを（を使用せずに）持つことが理にかなっている理由については、以下のフラグメント（Chromeで動作します...）を参照してください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());

新しいes6クラス構文は、プロトタイプを持つ「古い」es5「クラス」のもう1つの表記法にすぎません。したがって、プロトタイプ（基本クラス）を設定せずに特定のクラスをインスタンス化することはできません。

それはそれを作らずにあなたのサンドイッチにチーズを置くようなものです。また、サンドイッチを作る前にチーズを入れることはできないので...

...でthisスーパークラスを呼び出す前にキーワードを使用すること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を呼び出したい場合に、場所と方法を選択できるようにすると、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");

乾杯！

サブクラスでコンストラクターを完全に省略した場合、サブクラスで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()を使用してください。

このソリューションでは、インスタンス化ごとに追加のメソッドにステップインする必要があるため、デバッグが面倒です。

試してください：

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();

Demo

以下のOOP概念を開発する場合は、OODK-JSの使用をお勧めします。

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
    }
}

@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（親クラス）と内childMethod()の子供のB私たちがしているthisオブジェクトを指しているobj私たちはBさんに作成constructorしてObject.create(new.target.prototype)。

そして、これをまったく気にせずにsuper。

これは、JSではconstructor、クライアントコードがを使用して新しいインスタンスを作成するときに、完全に異なるオブジェクトを返すことができるという事実を利用していますnew。

これが誰かを助けることを願っています。