Esta pregunta ya tiene una respuesta aquí:

He encontrado un problema a continuación con JavaScript (ES6)

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");
  }
}

Lo que espero es

foo in A is called
foo in B is called

Pero en realidad es

foo in B is called
foo in B is called

Sé que puedo resolver esto simplemente agregandosuper.foo() en la función foo de la clase B

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

Pero imagine un escenario similar a este:

El niño tiene que anular la función de los padres para hacer algunos trabajos adicionales y evitar que el acceso externo pueda acceder al original.

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");
    };
  }
}

Parece quethis todavía señala al niñoB mientras construyendo en padreA. Es por eso que no puedo contactar a los padresA'sfoo.

Como hagothis para llamar a la función de versión principal que está anulando el elemento secundario durante la cadena del constructor?

¿O hay alguna solución mejor cuando se trata de un escenario como este?

Editar

Entonces, después de leer las respuestas, la pregunta principal se convierte en:

¿Se desaconseja ponerinitialize helpers osetter functions en constructor en JavaScript ya que los niños tienen la oportunidad de anularlos?

Para aclarar la situación más claramente: (perdón por mi mal ejemplo anterior :()

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 estaránundefined.

¿Es una mala idea ya que child podrá anular la función?

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

Entonces no debería usarinitialize helpers osetter functions en constructor como en Java, C ++ ...?

¿Debo llamar manualmente a cosas como esta?new A().init() para ayudarme a inicializar las cosas?