Kas ir ģeneriki (Generics) programmēšanā?

Ģeneriski (Generics) ir mehānisms programmēšanas valodās, kas ļauj izveidot komponentus (klases, interfeisi, metodes/funkcijas), kas darbojas ar dažādiem datu tipiem, nezaudējot tipa drošību un neizmantojot tipu pārvēršanu (casting).

Galvenie mērķi, izmantojot Generics:

• Palielināt tipa drošību: Kompilers pārbauda tipus kompilācijas laikā, atklājot kļūdas pirms programmas izpildes.
• Uzlabot koda lasāmību: Skaidri redzams, ar kādiem datu tipiem darbojas komponents.
• Atkārtota koda izmantošana: Var izveidot vienu komponentu, kas darbojas ar dažādiem tipiem, nevis rakstīt vairākas versijas.
• Samazināt tipu pārvēršanu: Atbrīvo no nepieciešamības veikt skaidru tipu pārvēršanu, padarot kodu tīrāku un mazāk pakļautu kļūdām ClassCastException (piemēram, Java valodā).

Generics izmantošanas piemēri:

• Kolekcijas: Saraksti (List), kopas (Set), kartes (Map) var glabāt elementus noteiktā tipā, kas garantē, ka kolekcijā neiekļausies citu tipu elementi.
• Metodes/funkcijas: Metode var strādāt ar parametriem vai atgriezt vērtību universālā tipā.
• Klases/interfeisi: Var izveidot universālas datu struktūras vai uzvedības šablonus.

Java piemērs:

// Generiskais pāra klases piemērs
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;
    }
}

// Lietošana
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // Nav nepieciešama tipu pārvēršana
int num = pair.getSecond();   // Nav nepieciešama tipu pārvēršana

// Pair<String, Integer> nepareiza pāra definīcija - kompilācijas kļūda: tipu nesaskaņa

C# piemērs:

// Generiskā pāra klases piemērs
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;
    }
}

// Lietošana
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // Nav nepieciešama tipu pārvēršana
int num = pair.Second;   // Nav nepieciešama tipu pārvēršana

// var nepareiza pāra definīcija - kompilācijas kļūda

TypeScript piemērs:

// Generiska funkcija, kas atgriež pirmo elementu masīvā
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Lietošana
let numbers: number[] = [1, 2, 3];
let firstNumber = getFirstElement(numbers); // firstNumber ir tipa number

let words: string[] = ["a", "b", "c"];
let firstWord = getFirstElement(words);   // firstWord ir tipa string

// let mixedArray: (number | string)[] = [1, "a", 2];
// let firstMixed = getFirstElement(mixedArray); // firstMixed ir tips: number | string

Tādējādi, Generics ir spēcīgs rīks, lai izveidotu elastīgu, tipa drošu un atkārtoti izmantojamu kodu.