Funktionsoverbelastning i TypeScript

Somme steder møder man funktioner, som returnerer værdier, hvis type afhænger af de overførte parametre. For dette bruger TypeScript overbelastning af funktioner. Det tillader at angive forskellige varianter af funktionens signaturer.

Lad os se på et eksempel. Antag at vi har en funktion, som opdeler tegnene i en streng i et array af bogstaver:

function splitStr(str: string): string[] {
	return str.split('');
}

Antag at vi også har en funktion, som opdeler cifre i et tal i et array af cifre:

function splitNum(num: number): number[] {
	let str: string = String(num);
	let arr: string[] = str.split('');
	
	return arr.map(elem => +elem);
}

Lad os kombinere begge funktioner til én. Den nye funktion skal afhængigt af parameterens type returnere enten et array af tal eller et array af strenge.

Vi bruger overbelastning til at deklarere forskellige signaturer for vores funktion:

function splitVal(val: number): number[];
function splitVal(val: string): string[] {
	// implementering af begge signaturer
}

Lad os nu skrive funktionens implementering. I dens kode skal vi med en betingelse afgøre, hvilken af funktionens signaturer der blev aktiveret, og afhængigt af dette køre den nødvendige kode med et resultat af den ønskede type:

function splitVal(val: number): number[];
function splitVal(val: string): string[] {
	if (typeof val === 'string') {
		return val.split('');
	} else {
		let str: string = String(val);
		let arr: string[] = str.split('');
		
		return arr.map((elem: string): number => +elem);
	}
}

I modsætning til andre sprog, skabes der i TypeScript én funktion i overbelastningen. Man kan ikke lave flere funktioner med samme navn, men med forskellige signaturer.

Skriv en funktion, som vil returnere eller ændre teksten i et DOM-element. Den skal fungere på følgende måde:

text('#elem', 'text'); // sætter teksten
text('#elem');         // returnerer den nuværende tekst