Antwort.

Hintergrund

In Sprachen wie Java oder C# ist die Überladung von Funktionen und Methoden eine Standardfunktion: Man kann mehrere Funktionen mit dem gleichen Namen, aber unterschiedlichen Parametern deklarieren. In JavaScript gibt es das nicht, was potenzielle Fehler hinzufügt. TypeScript löst dieses Problem auf der Ebene der Typen.

Problem

In TypeScript gibt es keine echte Überladung (mehrfache Implementierungen). Man kann mehrere Signaturen einer Funktion deklarieren, aber nur eine Funktion implementieren. Fehler treten auf, wenn die deklarierten Signaturen und die Implementierung nicht übereinstimmen oder die Signaturen falsch positioniert sind.

Lösung

TypeScript unterstützt die Überladung von Funktionen durch die Deklaration mehrerer Signaturen nacheinander und einer einzigen tatsächlichen Implementierung, die mit allen Überladungsvarianten kompatibel ist.

Codebeispiel:

function sum(a: number, b: number): number;
function sum(a: string, b: string): string;
function sum(a: any, b: any): any {
  return a + b;
}

const a = sum(1, 2); // 3
const b = sum('foo', 'bar'); // "foobar"

Schlüsselmerkmale:

Immer eine Implementierung nach allen Signaturen
Die Implementierung muss mit allen Überladungsvarianten kompatibel sein
TypeScript überprüft die Korrektheit des Aufrufs bei der Verwendung der überladenen Funktion

Fangfragen.

Kann die Implementierung der Funktion vor der Deklaration aller Überladungssignaturen definiert werden?

Nein, zuerst müssen alle Überladungssignaturen vorhanden sein, gefolgt von der Implementierung. Fehler:

// Fehler! Zuerst Signaturen, dann Implementierung
function foo(a: number): number { return a } // Fehler
function foo(a: string): string { return a } // Fehler

Überprüft TypeScript die Rückgabewerte in allen Überladungssignaturen?

TypeScript garantiert die Rückgabe von Typen gemäß den deklarierten Signaturen nur zur Kompilierungszeit; es erfolgt keine Typüberprüfung zur Laufzeit.

Muss die gesamte Bandbreite der Eingabewerte in der einzigen Implementierung abgedeckt werden?

Die Implementierungsfunktion sollte alle Varianten der Eingabewerte gemäß den Überladungssignaturen korrekt verarbeiten:

function parse(a: number): string;
function parse(a: string): string;
function parse(a: number | string): string {
  return String(a);
}

Typische Fehler und Anti-Pattern

Ungleichgewicht zwischen Implementierung und Überladungssignaturen
Falsche Reihenfolge der Deklaration von Signaturen und Implementierung
Implizite Verarbeitung/Übersehen von Typkombinationen

Beispiel aus dem Leben

Negativer Fall

Es wurden mehrere Überladungen der Funktion mit unterschiedlichen Eingangstypen deklariert, aber die Implementierung verarbeitet nicht alle Fälle und wirft zur Laufzeit einen Fehler bei seltenen Eingaben.

Vorteile:

Flexibles API für Benutzer der Funktion

Nachteile:

Typen werden kompiliert, aber die Funktion arbeitet nicht korrekt ohne zusätzliche Überprüfungen im Inneren

Positiver Fall

Jede Überladung der Funktion wird innerhalb der Implementierung durch Typbedingungen abgedeckt, Typüberprüfungen (typeof/instanceof) werden verwendet.