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 fonctionSyntaxe 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"));
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"));
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"));
// 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));
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);
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