Funktionsöverlagring i TypeScript

Ibland stöter man på funktioner som returnerar värden vars typ beror på de parametrar som skickas. För detta använder TypeScript funktionsöverlagring (funktionsöverlagring). Det gör det möjligt att ange olika varianter av funktionens signaturer.

Låt oss titta på ett exempel. Låt oss säga att vi har en funktion som delar upp tecknen i en sträng till en array av bokstäver:

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

Låt oss också säga att vi har en funktion som delar upp siffrorna i ett nummer till en array av siffror:

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

Låt oss kombinera båda funktionerna till en. Den nya funktionen ska, beroende på parameterns typ, returnera antingen en array med nummer eller en array med strängar.

Låt oss använda överlagring för att deklarera olika signaturer för vår funktion:

function splitVal(val: number): number[];
function splitVal(val: string): string[] {
	// implementering av båda signaturerna
}

Låt oss nu skriva implementeringen av funktionen. I dess kod måste vi med ett villkor avgöra vilken av funktionens signaturer som utlöstes, och beroende på detta köra rätt kod med ett resultat av rätt typ:

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);
	}
}

Till skillnad från andra språk, skapas i TypeScript en enda funktion vid överlagring. Det går inte att skapa flera funktioner med samma namn, men med olika signaturer.

Skriv en funktion som returnerar eller ändrar texten i ett DOM-element. Den ska fungera på följande sätt:

text('#elem', 'text'); // sätter texten
text('#elem');         // returnerar den nuvarande texten