Sobrecarga de funciones en TypeScript

La sobrecarga de funciones (Function Overloading) permite definir múltiples firmas para una función, y el compilador selecciona la implementación correcta según los tipos de parámetros pasados.

Diagrama SVG: Flujo de sobrecarga de funciones Fondo Título Cómo funciona la sobrecarga de funciones Lado izquierdo Firmas de sobrecarga de funciones (declaraciones) // Firma 1 function add(a: number, b: number): number; // Firma 2 function add(a: string, b: string): string; Flecha (desplazada hacia abajo para evitar superposición) Coincidencia del compilador (desplazada hacia arriba) Compilador Coincidencia Lado derecho Implementación de la función (código real) function add(a: any, b: any): any { return a + b; } Debe ser compatible con todas las firmas Mitad inferior Inferencia de tipos en la llamada Ejemplo add(1, 2) → number add("a", "b") → string add(true, false) → any Definición de la flecha

Sintaxis básica

Primero se declaran múltiples firmas de función, luego se implementa una función unificada.

Ejemplo

// Firmas de sobrecarga de función
function add(a: number, b: number): number;
function add(a: string, b: string): string;
function add(a: any, b: any): any {
    return a + b;
}

console.log("Suma de números: " + add(1, 2));
console.log("Suma de cadenas: " + add("Hello, ", "World"));

Resultado de la ejecución:

数字相加: 3
字符串相加: Hello, World

Sobrecarga con múltiples parámetros

Se pueden definir diferentes combinaciones de múltiples parámetros.

Ejemplo

// Múltiples firmas de sobrecarga
function greet(name: string): string;
function greet(name: string, greeting: string): string;

// Implementación
function greet(name: any, greeting?: any): any {
    if (greeting) {
        return greeting + ", " + name + "!";
    }
    return "Hello, " + name + "!";
}

console.log(greet("Alice"));
console.log(greet("Bob", "Hi"));

Resultado de la ejecución:

Hello, Alice!
Hi, Bob!

Sobrecarga de métodos

Los métodos de una clase también pueden usar sobrecarga.

Ejemplo

class Calculator {
    // Firmas de sobrecarga
    add(a: number, b: number): number;
    add(a: string, b: string): string;
    add(a: number, b: string): string;
    add(a: any, b: any): any {
        return a + b;
    }
}

var calc = new Calculator();
console.log("Número: " + calc.add(1, 2));
console.log("Cadena: " + calc.add("Hello", "World"));
console.log("Mezcla: " + calc.add(5, " apples"));

Resultado de la ejecución:

数字: 3
字符串: HelloWorld
混合: 5 apples

Sobrecarga de constructores

Los constructores también se pueden sobrecargar.

Ejemplo

class User {
    name: string;
    age: number;

    // Sobrecarga de constructor
    constructor(name: string);
    constructor(name: string, age: number);
    constructor(name: any, age?: any) {
        this.name = name;
        this.age = age || 0;
    }
}

var user1 = new User("Alice");
var user2 = new User("Bob", 25);

console.log("Usuario1: " + JSON.stringify(user1));
console.log("Usuario2: " + JSON.stringify(user2));

Resultado de la ejecución:

用户1: {"name":"Alice","age":0}
用户2: {"name":"Bob","age":25}

Sobrecarga y tipos de unión

Usar sobrecarga en lugar de tipos de unión permite una inferencia de tipos más precisa.

Ejemplo

// Recomendado: usar sobrecarga
function process(value: number): number;
function process(value: string): string;
function process(value: any): any {
    if (typeof value === "number") {
        return value * 2;
    }
    return value.toUpperCase();
}

// TypeScript conoce el tipo de retorno
var numResult: number = process(10);  // number
var strResult: string = process("hello");  // string

console.log("Resultado numérico: " + numResult);
console.log("Resultado de cadena: " + strResult);

Resultado de la ejecución:

数字结果: 20
字符串结果: HELLO

Notas

  • Las firmas de sobrecarga deben colocarse antes de la firma de implementación.
  • La firma de implementación debe ser compatible con todas las firmas de sobrecarga.
  • Las firmas de sobrecarga son solo declaraciones de tipos, no generan código real.

Resumen

  • Sobrecarga de funciones:Define múltiples firmas, el compilador selecciona la implementación que coincide.
  • Sobrecarga de métodos:También aplicable en clases.
  • Sobrecarga de constructores:Proporciona múltiples formas de inicialización.
  • Superior a los tipos de unión:Tipo de retorno más preciso.
Otras extensiones