Diese Frage hat hier bereits eine Antwort:

Ich habe unten ein Problem mit JavaScript (ES6) festgestellt.

class A{
  constructor(){
    this.foo();
  }
  foo(){
    console.log("foo in A is called");
  }
}

class B extends A{
  constructor(){
    super();
    this.foo();
  }
  foo(){
    console.log("foo in B is called");
  }
}

as ich erwarte ist

foo in A is called
foo in B is called

Aber eigentlich ist es

foo in B is called
foo in B is called

Ich weiß, dass ich das beheben kann, indem ich einfach @ hinzufügsuper.foo() in Klasse B's Foo-Funktion

class B extends A{
  constructor(){
    super();
    this.foo();
  }
  foo(){
    super.foo() // add this line
    console.log("foo in B is called");
  }
}

Aber stellen Sie sich ein ähnliches Szenario vor:

Child muss die Funktion des Elternteils überschreiben, um zusätzliche Arbeiten ausführen zu können und zu verhindern, dass der Zugriff von außen auf das Original erfolgt.

class B extends A{
  constructor(){
    super();
    this.initBar();
  }
  foo(){
    super.foo();
    this.bar.run(); //undefined
    console.log("foo in B is called");
  }
  initBar(){
    this.bar.run = function(){
      console.log("bar is running");
    };
  }
}

Es scheint, dassthis zeigt immer noch auf KindB beim Konstruieren im übergeordnetenA. Deshalb kann ich Eltern nicht erreichenA 'sfoo.

Wie mache ichthis ruft die übergeordnete Versionsfunktion auf, die während der Konstruktorkette vom untergeordneten Element überschrieben wird?

Oder gibt es eine bessere Lösung für ein Szenario wie dieses?

Bearbeite

So wird nach dem Lesen der Antworten die Hauptfrage -

Ist es nicht ratsam, @ zu setzinitialize helpers odersetter functions im Konstruktor in JavaScript, da Kinder die Möglichkeit haben, sie zu überschreiben?

Um die Situation klarer zu klären: (Entschuldigung für mein vorheriges schlechtes Beispiel :()

class A{
  constructor(name){
    this.setName(name);
  }
  setName(name){
    this._name = name;
  }
}

class B extends A{
  constructor(name){
    super(name);
    this._div = document.createElementById("div");
  }
  setName(name){
    super.setName(name);
    this._div.appendChild(document.createTextNode(name));
  }
}

new B("foo")

this._div wird seinundefined.

Ist das eine schlechte Idee, da das Kind die Funktion überschreiben kann?

class A{
  constructor(name){
    this.setName(name); // Is it bad?
  }
  ...
}

So sollte ich nicht @ verwendinitialize helpers odersetter functions im Konstruktor wie in Java, C ++ ...?

Muss ich manuell Dinge wie diese aufrufennew A().init() um mir zu helfen, Dinge zu initialisieren?