Supraîncărcarea funcțiilor în TypeScript

Uneori există funcții care returnează valori al căror tip depinde de parametrii transmiși. Pentru aceasta în TypeScript se folosește supraîncărcarea funcțiilor. Ea permite indicarea diferitelor variante de semnături ale funcției.

Să privim un exemplu. Să presupunem că avem o funcție care împarte caracterele unui șir de caractere într-un array de litere:

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

Să presupunem că avem de asemenea o funcție care împarte cifrele unui număr într-un array de cifre:

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

Să combinăm ambele funcții într-una singură. Noua funcție în funcție de tipul parametrului trebuie să returneze fie un array de numere, fie un array de șiruri de caractere.

Vom folosi supraîncărcarea pentru a declara diferite semnături ale funcției noastre:

function splitVal(val: number): number[];
function splitVal(val: string): string[] {
	// implementarea ambelor semnături
}

Să scriem acum implementarea funcției. În codul ei trebuie să determinăm printr-o condiție care dintre semnăturile funcției s-a activat și, în dependență de aceasta, să executăm codul necesar cu un rezultat de tipul necesar:

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

Spre deosebire de alte limbaje, în TypeScript la supraîncărcare se creează o singură funcție. Nu se poate face mai multe funcții cu același nume, dar cu semnături diferite.

Scrieți o funcție care va returna sau va modifica textul unui element DOM. Ea trebuie să funcționeze în felul următor:

text('#elem', 'text'); // va seta textul
text('#elem');         // va returna textul curent