Sobrecarga de constructores en TypeScript: cómo hacerlo correcta y elegantemente

Sobrecarga de constructores en TypeScript: de principiante a profesional

Imagine: está escribiendo una clase User que debe poder crearse desde diferentes fuentes. Desde una cadena JSON, desde un objeto con datos, y a veces incluso sin parámetros — solo un perfil vacío. En JavaScript, simplemente verificaría los tipos dentro de un solo constructor. Pero TypeScript nos brinda una herramienta mucho más elegante y segura: la sobrecarga de constructores.

Este tema es un verdadero éxito en Stack Overflow. Miles de desarrolladores buscan la respuesta a la pregunta: «¿Cómo implementar múltiples constructores en TypeScript?». Y no es de extrañar: la sobrecarga de constructores es un patrón poderoso que hace que su código sea flexible, legible y seguro en cuanto a tipos. En este artículo, cubriremos todo, desde «por qué es necesario» hasta «cómo hacerlo correctamente» con ejemplos reales.

¿Qué es la sobrecarga de constructores y por qué es necesaria?

En la POO clásica, la sobrecarga de constructores (constructor overload) es la capacidad de declarar múltiples constructores en una misma clase, cada uno con su propio conjunto de parámetros. TypeScript, a diferencia de JavaScript, admite este concepto, pero con una característica importante: a nivel de compilación. En tiempo de ejecución, una clase solo puede tener una implementación de constructor, pero TypeScript permite declarar varias firmas (sobrecargas) y luego escribir una implementación común que analice los argumentos.

¿Por qué es necesario? Consideremos tres escenarios:

• Flexibilidad de la API: su clase puede aceptar datos en diferentes formatos (cadena, objeto, array).
• Compatibilidad hacia atrás: agrega nuevos parámetros sin romper el código antiguo.
• Mejora de la DX (Experiencia del Desarrollador): el IDE sugerirá todas las posibles variantes de llamada al constructor.

Sintaxis de la sobrecarga de constructores: explicación sencilla

Vayamos al grano. Aquí hay un ejemplo clásico: la clase User, que se puede crear de tres maneras:

class User {    public name: string;    public age: number;    public email: string;

    // Sobrecarga 1: sin parámetros (usuario vacío)    constructor();    // Sobrecarga 2: solo nombre    constructor(name: string);    // Sobrecarga 3: datos completos    constructor(name: string, age: number, email: string);    // Implementación: una para todos los casos    constructor(name?: string, age?: number, email?: string) {        if (name === undefined) {            this.name = 'Guest';            this.age = 0;            this.email = '';        } else if (age === undefined) {            this.name = name;            this.age = 0;            this.email = '';        } else {            this.name = name;            this.age = age;            this.email = email ?? '';        }    }}

// Uso:const guest = new User();                // Guest, 0, ''const john = new User('John');           // John, 0, ''const jane = new User('Jane', 25, 'jane@mail.com'); // Jane, 25, jane@mail.com

Tenga en cuenta: tres firmas (sobrecargas) y una implementación. Las firmas son las «promesas» al compilador de TypeScript, y la implementación es «cómo funciona realmente». Los parámetros en la implementación deben ser opcionales (?) para cubrir todas las variantes.

Errores típicos en la sobrecarga de constructores

Los desarrolladores suelen tropezar con tres obstáculos:

• Error 1: Incompatibilidad de tipos. Si la firma promete string y la implementación recibe number, TypeScript mostrará un error. Todas las firmas deben ser compatibles con la implementación.
• Error 2: Orden de las sobrecargas. TypeScript selecciona la primera firma que coincida. Si tiene constructor(x: string | number) y constructor(x: string), la segunda nunca