TypeScript-Funktionsüberladung
Funktionsüberladung ermöglicht es, mehrere Signaturen für eine Funktion zu definieren, und der Compiler wählt die richtige Implementierung basierend auf den Typen der übergebenen Argumente aus.
SVG-Diagramm: Ablauf der FunktionsüberladungGrundlegende Syntax
Zuerst mehrere Funktionssignaturen deklarieren, dann eine einheitliche Funktion implementieren.
Beispiel
// Funktionsüberladungssignaturen
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("Zahlenaddition: " + add(1, 2));
console.log("String-Addition: " + add("Hallo, ", "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("Zahlenaddition: " + add(1, 2));
console.log("String-Addition: " + add("Hallo, ", "World"));
Ausgabe:
数字相加: 3 字符串相加: Hello, World
Überladen mit mehreren Parametern
Verschiedene Kombinationen mehrerer Parameter können definiert werden.
Beispiel
// Mehrere Überladungssignaturen
function greet(name: string): string;
function greet(name: string, greeting: string): string;
// Implementierung
function greet(name: any, greeting?: any): any {
if (greeting) {
return greeting + ", " + name + "!";
}
return "Hallo, " + name + "!";
}
console.log(greet("Alice"));
console.log(greet("Bob", "Hallo"));
function greet(name: string): string;
function greet(name: string, greeting: string): string;
// Implementierung
function greet(name: any, greeting?: any): any {
if (greeting) {
return greeting + ", " + name + "!";
}
return "Hallo, " + name + "!";
}
console.log(greet("Alice"));
console.log(greet("Bob", "Hallo"));
Ausgabe:
Hello, Alice! Hi, Bob!
Methodenüberladung
Methoden in Klassen können auch überladen werden.
Beispiel
class Calculator {
// Überladungssignaturen
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("Nummer: " + calc.add(1, 2));
console.log("Zeichenkette: " + calc.add("Hallo", "World"));
console.log("Gemischt: " + calc.add(5, " Äpfel"));
// Überladungssignaturen
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("Nummer: " + calc.add(1, 2));
console.log("Zeichenkette: " + calc.add("Hallo", "World"));
console.log("Gemischt: " + calc.add(5, " Äpfel"));
Ausgabe:
数字: 3 字符串: HelloWorld 混合: 5 apples
Konstruktorüberladung
Konstruktoren können auch überladen werden.
Beispiel
class User {
name: string;
age: number;
// Konstruktorüberladung
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("Benutzer 1: " + JSON.stringify(user1));
console.log("Benutzer 2: " + JSON.stringify(user2));
name: string;
age: number;
// Konstruktorüberladung
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("Benutzer 1: " + JSON.stringify(user1));
console.log("Benutzer 2: " + JSON.stringify(user2));
Ausgabe:
用户1: {"name":"Alice","age":0}
用户2: {"name":"Bob","age":25}
Überladung und Union-Typen
Die Verwendung von Überladung anstelle von Union-Typen ermöglicht eine präzisere Typinferenz.
Beispiel
// Empfohlen: Überladung verwenden
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 kennt den Rückgabetyp
var numResult: number = process(10); // number
var strResult: string = process("hello"); // string
console.log("Zahlenergebnis: " + numResult);
console.log("Zeichenketten-Ergebnis: " + 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 kennt den Rückgabetyp
var numResult: number = process(10); // number
var strResult: string = process("hello"); // string
console.log("Zahlenergebnis: " + numResult);
console.log("Zeichenketten-Ergebnis: " + strResult);
Ausgabe:
数字结果: 20 字符串结果: HELLO
Hinweise
- Überladungssignaturen müssen vor der Implementierungssignatur platziert werden
- Die Implementierungssignatur muss mit allen Überladungssignaturen kompatibel sein
- Überladungssignaturen sind nur Typdeklarationen und generieren keinen tatsächlichen Code
Zusammenfassung
- Funktionsüberladung:Mehrere Signaturen definieren, und der Compiler wählt die passende Implementierung aus
- Methodenüberladung:Auch in Klassen anwendbar
- Konstruktorüberladung:Bietet mehrere Initialisierungsmethoden
- Besser als Union-Typen:Präzisere Rückgabetypen