Esta pergunta já tem uma resposta aqui:

Encontrei um problema abaixo com 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");
  }
}

O que eu espero é

foo in A is called
foo in B is called

Mas na verdade é

foo in B is called
foo in B is called

Eu sei que posso resolver isso simplesmente adicionandosuper.foo() na função foo da classe B

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

Mas imagine um cenário semelhante a este:

A criança precisa substituir a função dos pais para realizar alguns trabalhos extras e impedir que o acesso externo possa acessar o 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 ainda aponta para criançaB enquanto constrói no paiA. É por isso que não consigo alcançar os paisAéfoo.

Como eu façothis chamar a função da versão pai que está sendo substituída pelo filho durante a cadeia de construtores?

Ou existe alguma solução melhor quando se trata de um cenário como este?

Editar

Então, depois de ler as respostas, a questão principal se torna -

É desencorajado a colocarinitialize helpers ousetter functions no construtor em JavaScript, já que as crianças têm a chance de substituí-las?

Para esclarecer a situação com mais clareza: (desculpe pelo meu mau exemplo 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 seráundefined.

É uma má idéia, pois o filho poderá substituir a função?

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

Então eu não deveria usarinitialize helpers ousetter functions no construtor como em Java, C ++ ...?

Devo chamar manualmente coisas como estanew A().init() para me ajudar a inicializar as coisas?