Ի՞նչ են ընդհանուր օգտագործումները (Generics) ծրագրավորման մեջ։

Ձևավորումները (Generics) մեխանիզմ են ծրագրավորման լեզուներում, որը թույլ է տալիս ստեղծել բաղադրիչներ (клаասներ, ինտերֆեյսներ, մեթոդներ/ֆունկցիաներ), որոնք աշխատում են տարբեր տվյալների տիպերով, առանց կորցնելու տիպային անվտանգությունը և առանց անհրաժեշտության տիպային փոխարկումների (casting):

Generics-ների հիմնական նպատակները՝

• Տիպային անվտանգության բարձրացում: Կոմպիլյատորը ստուգում է տիպերը կոմպիլացիայի ժամանակ, հայտնաբերում սխալները նախքան ծրագրի գործարկումը:
• Կոդի ընթեռնելիության բարելավում: Հստակ է, թե ինչ տիպի տվյալների հետ է աշխատում բաղադրիչը:
• Կոդի կրկնակի օգտագործում: Կարող եք ստեղծել մի բաղադրիչ, որը աշխատում է տարբեր տիպերով, փոխարենը գրել մի քանի տարբերակ:
• Տիպային փոխարկումների նվազեցում: Խուսափում է անհրաժեշտությունից բացահայտ տիպային փոխարկումների, ինչը դարձնում է կոդը ավելի մաքուր և քիչ սխալների ենթակա ClassCastException (որտեղ դա կիրառելի է, օրինակ, Java-ում):

Generics-ների օգտագործման օրինակներ՝

• Կազմածիններ: Ցուցակներ (List), հավաքածուներ (Set), քարտեզներ (Map) կարող են պահել որոշակի տիպի տարրեր, ինչը երաշխավորում է, որ այլ տիպի տարրեր չեն մտնի հավաքածու:
• Մեթոդներ/ֆունկցիաներ: Մեթոդը կարող է աշխատել պարամետրերով կամ վերադարձնել ընդհանուր տիպի արժեք:
• Կլասներ/ինտերֆեյսներ: Կարող եք ստեղծել ընդհանուր տվյալների կառուցվածքներ կամ վարքագծի նմուշներ:

Օրինակ Java-ում՝

// Ընդհանուր զույգի դաս
public class Pair<T, U> {
    private T first;
    private U second;

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }
}

// Օգտագործում
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // Չի պահանջվում տիպային փոխարկում
int num = pair.getSecond(); // Չի պահանջվում տիպային փոխարկում

// Անհամապատասխան զույգ
Pair<String, Integer> wrongPair = new Pair<>(123, "Hello"); // Կոմպիլյատորի սխալ՝ տիպերի անհամապատասխանություն

C# օրինակ՝

// Ընդհանուր զույգի դաս
public class Pair<T, U> {
    public T First { get; set; }
    public U Second { get; set; }

    public Pair(T first, U second) {
        First = first;
        Second = second;
    }
}

// Օգտագործում
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // Չի պահանջվում տիպային փոխարկում
int num = pair.Second; // Չի պահանջվում տիպային փոխարկում

// Անհամապատասխան զույգ
var wrongPair = new Pair<string, int>(123, "Hello"); // Կոմպիլյատորի սխալ

TypeScript օրինակ՝

// Ընդհանուր ֆունկցիա առաջին տարրն ստանալու համար
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Օգտագործում
let numbers: number[] = [1, 2, 3];
let firstNumber = getFirstElement(numbers); // firstNumber ունի տիպ `number`

let words: string[] = ["a", "b", "c"];
let firstWord = getFirstElement(words); // firstWord ունի տիպ `string`

// let mixedArray: (number | string)[] = [1, "a", 2];
// let firstMixed = getFirstElement(mixedArray); // firstMixed ունի տիպ `number | string`

Այսպիսով, Generics-ները հզոր գործիք են ճկուն, տիպային անվտանգ և վերօգտագործելի կոդ ստեղծելու համար։