Przeciążenia funkcji w TypeScript

Czasami spotykamy funkcje, które zwracają wartości, których typ zależy od przekazanych parametrów. W tym celu w TypeScript używa się przeciążenia funkcji. Pozwala ono wskazać różne warianty sygnatur funkcji.

Spójrzmy na przykład. Załóżmy, że mamy funkcję, która dzieli znaki ciągu na tablicę liter:

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

Załóżmy, że mamy także funkcję, która dzieli cyfry liczby na tablicę liczb:

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

Połączmy obie funkcje w jedną. Nowa funkcja w zależności od typu parametru powinna zwracać albo tablicę liczb, albo tablicę ciągów znaków.

Użyjmy przeciążenia, aby zadeklarować różne sygnatury naszej funkcji:

function splitVal(val: number): number[];
function splitVal(val: string): string[] {
	// implementacja obu sygnatur
}

Napiszmy teraz implementację funkcji. W jej kodzie musimy warunkiem określić, która z sygnatur funkcji została wywołana, i w zależności od tego uruchomić odpowiedni kod z wynikiem odpowiedniego typu:

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

W przeciwieństwie do innych języków, w TypeScript w przeciążeniu tworzona jest jedna funkcja. Nie można utworzyć wielu funkcji o jednej nazwie, ale z różnymi sygnaturami.

Napisz funkcję, która będzie zwracać lub zmieniać tekst elementu DOM. Powinna ona działać w następujący sposób:

text('#elem', 'text'); // ustawi tekst
text('#elem');         // zwróci aktualny tekst