TypeScript Advanced Generics forklaret med eksempler

Generics i TypeScript giver en måde at skabe genanvendelige og fleksible kodekomponenter ved at arbejde med en række forskellige datatyper. Avancerede generiske artikler tager dette koncept videre ved at introducere yderligere funktioner som begrænsninger, standardværdier og flere typer, som gør det muligt for udviklere at skrive mere robust og typesikker kode. I denne artikel vil eksempler blive brugt til at udforske disse avancerede begreber inden for generiske lægemidler.

Generiske begrænsninger

Begrænsninger begrænser de typer, som en generisk kan acceptere. Dette sikrer, at typen, der sendes til en generisk funktion eller klasse, opfylder visse kriterier. For eksempel kan en begrænsning bruges til at sikre, at den generiske type har en specifik egenskab eller metode.

function getLength<T extends { length: number }>(arg: T): number {
    return arg.length;
}

const stringLength = getLength("TypeScript");
const arrayLength = getLength([1, 2, 3]);

I dette eksempel sikrer <T extends { length: number }>-begrænsningen, at argumentet, der sendes til getLength, har en length egenskab.

Flere generiske

TypeScript tillader brugen af ​​flere generiske typer i samme funktion, klasse eller grænseflade. Dette er nyttigt, når du arbejder med værdipar eller andre datastrukturer, der involverer flere typer.

function pair<T, U>(first: T, second: U): [T, U] {
    return [first, second];
}

const stringNumberPair = pair("TypeScript", 2024);

Denne funktion, par, accepterer to forskellige generiske typer, T og U, og returnerer en tuple, der indeholder begge typer.

Standard generiske typer

Generiske i TypeScript kan også have standardtyper. Dette er nyttigt, når du ønsker, at en generisk type skal have en reservetype, hvis der ikke er angivet nogen specifik type.

function identity<T = string>(value: T): T {
    return value;
}

const defaultString = identity("Hello");  // T is string
const customNumber = identity<number>(100);  // T is number

I dette eksempel, hvis ingen type sendes til identitet, er den standard til streng.

Brug af generiske stoffer med grænseflader

Generisk kan bruges med grænseflader til at definere komplekse strukturer, hvor typer ikke er faste. Dette tilføjer fleksibilitet til, hvordan data administreres.

interface Container<T> {
    value: T;
}

const stringContainer: Container<string> = { value: "Hello" };
const numberContainer: Container<number> = { value: 42 };

Container-grænsefladen er designet til at holde en værdi af enhver type, hvilket giver mulighed for forskellige slags containere med specifikke typer.

Generiske klasser

Klasser i TypeScript kan også være generiske. Dette er især nyttigt, når du designer klasser, der fungerer med forskellige datatyper, såsom datalagring eller indsamlingsklasser.

class DataStore<T> {
    private data: T[] = [];

    add(item: T): void {
        this.data.push(item);
    }

    getAll(): T[] {
        return this.data;
    }
}

const stringStore = new DataStore<string>();
stringStore.add("Hello");
stringStore.add("TypeScript");

const numberStore = new DataStore<number>();
numberStore.add(42);

I dette eksempel fungerer DataStore-klassen med enhver type data, hvilket giver en typesikker måde at gemme og hente elementer på.

Konklusion

Avancerede generiske artikler i TypeScript er et kraftfuldt værktøj til at skrive fleksibel, genbrugelig og typesikker kode. Ved at bruge begrænsninger, flere typer, standardværdier og generiske elementer i klasser og grænseflader, kan udviklere skrive mere kompleks og robust kode. Forståelse og brug af disse avancerede koncepter giver mulighed for større fleksibilitet og sikrer typesikkerhed på tværs af applikationer.