Respuesta.

Historia de la cuestión:

TypeScript soporta la sobrecarga de métodos, de manera similar a otros lenguajes con tipado estricto (como Java o C#), pero la sintaxis de sobrecarga en TypeScript difiere conceptualmente. Se permiten varias firmas, pero solo una implementación. Esto puede llevar a confusión para los desarrolladores familiarizados con la sobrecarga clásica.

Problema:

Un error común es intentar definir varios métodos con diferentes conjuntos de parámetros. Como resultado, se produce un error de compilación, ya que TypeScript requiere una implementación que cumpla con todas las variantes de las firmas.

Solución:

La sobrecarga se logra declarando varias firmas del método, y luego una implementación que se ajuste a todas las opciones. Para diferenciar correctamente los parámetros, se suelen utilizar type guards o instanceof.

Ejemplo de código:

class MyLogger {
  log(message: string): void;
  log(message: string, level: 'info' | 'error'): void;
  log(message: string, level?: 'info' | 'error'): void {
    const lvl = level ?? 'info';
    console.log(`[${lvl}] ${message}`);
  }
}

Características clave:

Solo una implementación del método, pero varias declaraciones-firma
Se debe garantizar el manejo de todas las variantes de los parámetros de entrada dentro de la implementación
Los tipos en la implementación deben ser lo más amplios posible

Preguntas trampa.

¿Se puede implementar dos implementaciones de un mismo método con diferentes conjuntos de parámetros?

No. En TypeScript, solo se permite una implementación. Tener varios métodos con el mismo nombre es un error de sintaxis.

¿Cómo tipar los parámetros rest en la sobrecarga de métodos para no perder la tipificación estricta?

Se recomienda describir los parámetros exactos en las firmas, y en la implementación, los más generales:

class Test {
  doWork(a: number): void;
  doWork(a: string): void;
  doWork(a: number | string): void {
    //...
  }
}

¿Qué sucederá si los tipos de retorno de las firmas sobrecargadas son diferentes?

TypeScript requerirá que la implementación retorne un tipo combinado (Union). De lo contrario, habrá un error de compilación.

class X {
  get(value: number): string;
  get(value: string): number;
  get(value: number | string): string | number {
    return typeof value === 'number' ? 'number' : 42;
  }
}

Errores típicos y anti-patrones

Inconsistencia entre la implementación y las firmas de sobrecarga
Varias implementaciones separadas de un mismo método
Ignorar la verificación de tipos de los parámetros de entrada en el cuerpo del método

Ejemplo de la vida real

Caso negativo

En el producto se intentó implementar dos métodos con el mismo nombre para diferentes tipos de parámetros en la clase. Después de la compilación, el método "se reemplazaba" con la última declaración, ignorándose todas las otras versiones, y aparecían errores.

Ventajas:

Estilo familiar para algunos lenguajes

Desventajas:

En TypeScript no funciona completamente, errores en la compilación
Mayor riesgo de casos pasados por alto

Caso positivo

Se hicieron varias firmas con parámetros de tipo unión, y en el método se manejaron todas las opciones a través de type guards. El compilador advirtió de inmediato sobre problemas de tipo.