ფუნქციების გადატვირთვა TypeScript-ში

ზოგჯერ შეგვხვდება ფუნქციები, რომლებიც აბრუნებენ მნიშვნელობებს, რომელთა ტიპიც დამოკიდებულია გადაცემულ პარამეტრებზე. ამისთვის TypeScript-ში იყენებენ ფუნქციების გადატვირთვას ეს საშუალებას გვაძლევს მივუთითოთ ფუნქციის სხვადასხვა ვარიანტის სიგნატურები.

მოდით შევხედოთ მაგალითს. დავუშვათ, ჩვენ გვაქვს ფუნქცია, რომელიც ყოფს სტრიქონის სიმბოლოებს ასოების მასივში:

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

დავუშვათ, ჩვენ ასევე გვაქვს ფუნქცია, რომელიც ყოფს რიცხვის სიმბოლოებს ციფრების მასივში:

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

მოდით ორივე ფუნქცია გავაერთიანოთ ერთში. ახალ ფუნქციამ, პარამეტრის ტიპის მიხედვით, უნდა დააბრუნოს ან რიცხვების მასივი ან სტრიქონების მასივი.

გამოვიყენოთ გადატვირთვა, რათა განვაცხადოთ ჩვენი ფუნქციის სხვადასხვა სიგნატურები:

function splitVal(val: number): number[];
function splitVal(val: string): string[] {
	// ორივე სიგნატურის რეალიზაცია
}

ახლა დავწეროთ ფუნქციის რეალიზაცია. მის კოდში ჩვენ უნდა განვსაზღვროთ პირობით, რომელი სიგნატურა იმუშავა და მიხედვით ამისა გავუშვათ საჭირო კოდი საჭირო ტიპის შედეგით:

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

სხვა ენებისგან განსხვავებით, TypeScript-ში გადატვირთვაში იქმნება ერთი ფუნქცია. არ შეიძლება გაკეთდეს რამდენიმე ფუნქცია ერთი სახელით, მაგრამ განსხვავებული სიგნატურებით.

დაწერეთ ფუნქცია, რომელიც დააბრუნებს ან შეცვლის DOM ელემენტის ტექსტს. მან უნდა იმუშაოს შემდეგნაირად:

text('#elem', 'text'); // დააყენებს ტექსტს
text('#elem');         // დააბრუნებს მიმდინარე ტექსტს