Respuesta.

Historia de la cuestión

Inicialmente, JavaScript no tenía tipificación estricta de clases y sus constructores, lo que ocasionaba errores en tiempo de ejecución. TypeScript añadió un sistema de tipos para una programación más segura y soportó la tipificación de constructores con herencia, lo cual es importante para el desarrollo de aplicaciones grandes.

Problema

La tipificación de constructores en TypeScript requiere tener en cuenta simultáneamente la firma del constructor, el tipo de la instancia creada y las características de la herencia. Los problemas surgen si las firmas de los constructores en la clase base y la clase derivada difieren, o si solo se tipa el valor de retorno y no los parámetros de entrada del constructor.

Solución

En TypeScript se pueden tipar explícitamente los constructores a través de firmas especiales, utilizando la expresión new (...args: any[]) => T. Al heredar, es importante mantener la coherencia de las firmas y ampliar correctamente las clases base.

Ejemplo de código:

class Animal {
  constructor(public name: string) {}
}

class Dog extends Animal {
  constructor(name: string, public breed: string) {
    super(name);
  }
}

// Tipo del constructor
function createInstance<T>(C: new (...args: any[]) => T, ...args: any[]): T {
  return new C(...args);
}

const dog = createInstance(Dog, 'Rex', 'Labrador');

Características clave:

La firma del constructor es una entidad separada, declarada mediante new
Mantenimiento de la compatibilidad de parámetros entre el constructor base y el derivado
Posibilidad de crear instancias de forma genérica a través de constructores tipados

Preguntas capciosas.

¿Es posible declarar varios constructores en una clase, como en Java o C#?

No, TypeScript no soporta múltiples constructores. Para simular la sobrecarga se utilizan las sobrecargas de firmas (overloads) con una única implementación. Enfoque correcto:

class Example {
  constructor(x: string);
  constructor(x: number);
  constructor(x: number | string) {
    // Una implementación
  }
}

¿Se puede tipar solo el tipo de retorno del constructor, ignorando los parámetros?

No, la firma del constructor debe incluir obligatoriamente los parámetros. Ejemplo de una tipificación correcta:

interface Constructable<T> {
  new (...args: any[]): T;
}

Si en la clase hija se declara un constructor sin llamar a super, ¿qué pasará?

Habrá un error de compilación: el constructor de la subclase debe llamar a super antes de acceder a this.

Errores comunes y anti-patrones

Parámetros no coincidentes entre el constructor de la clase base y el derivado
Falta de llamada a super en el constructor hijo
Tipificación incorrecta del constructor al abstraer a través de fábricas

Ejemplo de la vida real

Caso negativo

En el proyecto se utilizó la clase base Animal con el constructor (name), y en el heredero Dog se añadió (name, breed), pero se olvidó ampliar correctamente la firma.

Pros:

Documentan nuevos parámetros

Contras:

Se rompe la compatibilidad al crear instancias a través de fábricas genéricas, errores en tiempo de compilación

Caso positivo

Tipo de constructor se extrajo por separado, la fábrica createInstance se parametrizó a través de CorrectConstructable<T>, y se respetaron las firmas.