Antwoord.

Geschiedenis van de vraag

In talen zoals Java of C# is functie- en methodenoverload een standaard mogelijkheid: je kunt meerdere functies met dezelfde naam, maar verschillende parameters, declareren. In JavaScript is dit niet mogelijk, wat potentieel tot fouten leidt. TypeScript lost dit probleem op op het niveau van types.

Probleem

In TypeScript is er geen echte overload (meerdere implementaties). Je kunt meerdere handtekeningen van één functie declareren, maar slechts één functie implementeren. Fouten ontstaan door desynchronisatie tussen de gedeclareerde handtekeningen en de implementatie, of door onjuiste positionering van de handtekeningen.

Oplossing

TypeScript ondersteunt functieoverload door meerdere handtekeningen achter elkaar te declareren en één enkele werkelijke implementatie die compatibel is met alle overload-opties.

Codevoorbeeld:

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"

Belangrijkste kenmerken:

Altijd één implementatie na alle handtekeningen
De implementatie moet compatibel zijn met alle overload-opties
TypeScript controleert de juistheid van de aanroep bij gebruik van de overloaded functie

Vragen met een valstrik.

Kun je de implementatie van een functie definiëren vóór het declareren van alle overload-handtekeningen?

Nee, eerst moeten alle overload-handtekeningen komen, dan pas de implementatie. Fout:

// Fout! Eerst handtekeningen, dan implementatie
function foo(a: number): number { return a } // fout
function foo(a: string): string { return a } // fout

Controleert TypeScript de return-waarden in alle overload-handtekeningen?

TypeScript garandeert dat de return-types overeenkomen met de gedeclareerde handtekeningen alleen op het compilatieniveau; er vindt geen typecontrole tijdens runtime plaats.

Moet je alle varianten van invoer in de enkele implementatie dekken?

De implementatiefunctie moet alle varianten van invoer correct verwerken volgens de overload-handtekeningen:

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

Typische fouten en anti-patronen

Ongelijkheid tussen implementatie en overload-handtekeningen
Onjuiste volgorde van declaratie van handtekeningen en implementatie
Impliciete verwerking/negeren van typecombinaties

Voorbeeld uit het leven

Negatief geval

Er zijn meerdere overloads van de functie met verschillende invoertypen gedeclareerd, maar de implementatie behandelt niet alle gevallen en gooit een fout tijdens runtime bij zeldzame invoer.

Voordelen:

Flexibele API voor gebruikers van de functie

Nadelen:

Type worden gecompileerd, maar de werking van de functie is onjuist zonder aanvullende controles binnen de body

Positief geval

Elke overload van de functie wordt gedekt door een typevoorwaarde binnen de implementatie, typecontrole wordt gebruikt (typeof/instanceof).