რა არის გენერიკები (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 არის ძლიერი ინსტრუმენტი მოქნილი, ტიპის უსაფრთხო და გადამეორებადი კოდის შექმნისთვის.