orientado - recorrer array de objetos javascript

¿Cómo puedo llamar a un superconstructor fuera de un constructor?

Question

Ahora que JavaScript tiene clases, me pregunto cómo es posible invocar a un superconstructor fuera del constructor de una clase.

Mi intento ingenuo fallido (resultados en un SyntaxError):

class A
{
constructor() { this.a = 1; }
}
function initB()
{
super(); // How to invoke new A() on this here?
this.b = 2;
}
class B extends A
{
constructor() { initB.call(this); }
}

Soy consciente de que en otro lenguaje como Java, un superconstructor solo puede invocarse dentro del constructor de una clase derivada, pero las clases ES6 son azúcar sintáctica para la herencia basada en prototipos, así que me sorprendería si esto no fuera factible usando funciones incorporadas del lenguaje. Simplemente no puedo entender la sintaxis adecuada.

Lo mejor que he encontrado hasta ahora es terriblemente como hacer trampa:

class A
{
constructor() { this.a = 1; }
}
function initB()
{
let newThis = new A();
newThis.b = 2;
return newThis;
}
class B extends A
{
constructor() { return initB(); }
}

Answer 1

Cada constructor de una clase que extends algo debe contener una llamada directa super(…) .
Las llamadas directas super(…) solo se pueden ubicar en constructores. Realmente no hay forma de evitar esto.

Realmente no debería colocar la lógica de inicialización de una clase en ningún otro lugar que no sea en su constructor. La solución directa y adecuada es no utilizar initB en absoluto:

class A {
constructor() { this.a = 1; }
}
class B extends A {
constructor() {
super();
this.b = 2;
}
}

Dicho esto, hay una forma de subvertir el requisito de " super() llamada debe estar en el constructor". ¡Ponerlo dentro de una función de flecha también cuenta! Entonces podrías hacer

class A {
constructor() { this.a = 1; }
}
function initB(_super) {
var b = _super();
b.b = 2;
}
class B extends A {
constructor() {
initB(() => super());
}
}

Prométeme que nunca haga eso, por favor.

Otro patrón no es llamar a super() en absoluto, lo que funciona siempre que devuelva un objeto desde el constructor. Con eso, puedes poner la construcción real del objeto en cualquier otro lugar:

class A {
constructor() { this.a = 1; }
}
function makeB() {
var b = Reflect.construct(A, [], B); // call the A constructor with B for the prototype
b.b = 2;
return b;
}
class B extends A {
constructor() {
return makeB();
}
}

Lo que realmente no es mucho mejor.