Surcharge de fonctions TypeScript

La surcharge de fonction permet de définir plusieurs signatures pour une fonction, et le compilateur sélectionne l'implémentation correcte en fonction des types des arguments passés.

Diagramme SVG : flux de surcharge de fonction Background Title How Function Overloading Works Left Side Function Overloading Signatures (Declarations) // Signature 1 function add(a: number, b: number): number; // Signature 2 function add(a: string, b: string): string; Arrow (moves down to avoid obstruction) Compiler Matching (moves up) Compiler Match Right Side Function Implementation (actual code) function add(a: any, b: any): any { return a + b; } Must be compatible with all signatures Lower Section Type Inference at Call Time Example add(1, 2) → number add("a", "b") → string add(true, false) → any Arrow Definition

Syntaxe de base

Déclarez d'abord plusieurs signatures de fonction, puis implémentez une fonction unifiée.

Exemple

// Signatures de surcharge de fonction
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("Addition de nombres : " + add(1, 2));
console.log("Addition de chaînes : " + add("Bonjour, ", "World"));

Sortie :

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

Surcharge de plusieurs paramètres

Différentes combinaisons de plusieurs paramètres peuvent être définies.

Exemple

// Signatures de surcharge multiples
function greet(name: string): string;
function greet(name: string, greeting: string): string;

// Implémentation
function greet(name: any, greeting?: any): any {
    if (greeting) {
        return greeting + ", " + name + "!";
    }
    return "Bonjour, " + name + "!";
}

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

Sortie :

Hello, Alice!
Hi, Bob!

Surcharge de méthode

Les méthodes des classes peuvent également utiliser la surcharge.

Exemple

class Calculator {
    // Signatures de surcharge
    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("Nombre: " + calc.add(1, 2));
console.log("Chaîne: " + calc.add("Bonjour", "World"));
console.log("Mixte: " + calc.add(5, " pommes"));

Sortie :

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

Surcharge des constructeurs

Les constructeurs peuvent également être surchargés.

Exemple

class User {
    name: string;
    age: number;

    // Surcharge de constructeur
    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("User 1: " + JSON.stringify(user1));
console.log("User 2: " + JSON.stringify(user2));

Sortie :

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

Surcharge et types union

L'utilisation de la surcharge au lieu des types union permet une inférence de type plus précise.

Exemple

// Recommandé : utiliser la surcharge
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 connaît le type de retour
var numResult: number = process(10);  // number
var strResult: string = process("hello");  // string

console.log("Résultat du nombre : " + numResult);
console.log("Résultat de la chaîne : " + strResult);

Sortie :

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

Notes

  • Les signatures de surcharge doivent être placées avant la signature d'implémentation
  • La signature d'implémentation doit être compatible avec toutes les signatures de surcharge
  • Les signatures de surcharge ne sont que des déclarations de type et ne génèrent pas de code réel

Résumé

  • Surcharge de fonction :Définissez plusieurs signatures, et le compilateur sélectionne l’implémentation correspondante
  • Surcharge de méthode :Également applicable dans les classes
  • Surcharge de constructeur :Fournit plusieurs méthodes d'initialisation
  • Mieux que les types union :Des types de retour plus précis
Autres extensions