TypeScript generics – återanvändbar och typsäker kod
För robotar
TypeScript generics – återanvändbar och typsäker kod
TypeScript generics låter dig skriva funktioner, klasser och gränssnitt som fungerar med många olika datatyper utan att offra typsäkerheten. Istället för att skriva nästan samma kod flera gånger för strängar, tal och objekt skapar du en mall som TypeScript kontrollerar vid kompileringstiden.
För webbutvecklare som bygger återanvändbara komponenter, API-klienter eller verktygsfunktioner är generics ett av de mest praktiska verktygen i språket. Här går vi igenom vad det är, hur du använder det och vilka fallgropar du ska undvika.
Vad är generics egentligen?
Generics betyder att du skriver kod som är parametrerad över en typ. Du anger en typvariabel – oftast kallad T – som fylls i när koden används. På så sätt kan en och samma funktion hantera strängar, nummer, objekt eller dina egna interfaces, medan TypeScript fortfarande vet exakt vilken typ som returneras.
Utan generics hamnar du snabbt i ett val mellan två dåliga alternativ: antingen skriver du en separat funktion för varje typ, eller så använder du any och ger upp typsäkerheten helt. Generics ger dig en tredje väg.
Ett konkret exempel: en funktion som returnerar det första elementet
Tänk dig en funktion som tar en array och returnerar det första elementet. Utan generics ser den ut så här:
function firstElement(arr: any[]): any {
return arr[0];
}
Problemet är att any döljer informationen. Om du skickar in en array av strängar får du tillbaka any, och TypeScript kan inte varna dig om du försöker använda resultatet som ett nummer.
Med generics blir det så här:
function firstElement<T>(arr: T[]): T | undefined {
return arr[0];
}
Nu anger <T> att funktionen arbetar med en okänd typ T. Om du skickar in string[] vet TypeScript att returvärdet är string | undefined. Om du skickar in number[] blir det number | undefined. Samma kod, full typsäkerhet.
Generics i gränssnitt och typer
Generics är inte bara för funktioner. Du kan använda dem i interfaces och typalias också, vilket är särskilt användbart för API-svar och datamodeller.
interface ApiResponse<T> {
data: T;
status: number;
ok: boolean;
}
const userResponse: ApiResponse<{ id: number; name: string }> = {
data: { id: 1, name: "Anna" },
status: 200,
ok: true,
};
Här beskriver ApiResponse<T> ett generiskt svar från en API: data kan vara vad som helst, men när du använder typen bestämmer du exakt vad data innehåller. Det gör koden lättare att underhålla när API:et förändras.
Generics i klasser
Även klasser kan vara generiska. Ett vanligt exempel är en enkel lagringsklass:
class Storage<T> {
private items: T[] = [];
add(item: T): void {
this.items.push(item);
}
getAll(): T[] {
return this.items;
}
}
const stringStorage = new Storage<string>();
stringStorage.add("hej");
const numberStorage = new Storage<number>();
numberStorage.add(42);
Varje instans får sin egen typ. stringStorage accepterar bara strängar, och numberStorage bara nummer. TypeScript fångar fel som att lägga till ett nummer i stränglagret redan när du skriver koden.
Type constraints: begränsa vilka typer som är tillåtna
Ibland vill du inte acceptera vilken typ som helst. Du vill bara acceptera typer som har vissa egenskaper. Då använder du type constraints med extends.
Tänk dig en funktion som loggar en objekts length-egenskap:
function logLength<T extends { length: number }>(item: T): void {
console.log(item.length);
}
logLength("hej"); // fungerar, strängar har length
logLength([1, 2, 3]); // fungerar, arrayer har length
logLength({ name: "Anna" }); // fel: objektet har ingen length-egenskap
Constraints gör generics mer förutsägbara och låter dig komma åt egenskaper som du vet att alla tillåtna typer har.
Generics med Node.js och TypeScript
Om du bygger en Node.js-applikation med TypeScript är generics särskilt användbara för repository-klasser, tjänstlager och typsäkra API-klienter. I vår guide om Node.js med TypeScript går vi igenom hur du sätter upp projektet, och generics är ett naturligt nästa steg för att göra kodbasen mer återanvändbar.
Vanliga misstag med generics
Att överanvända any istället för generics
Det är frestande att använda any när du inte vet vilken typ som ska komma, men då förlorar du hela poängen med TypeScript. Byt ut any mot en typvariabel så att typsäkerheten följer med genom hela programmet.
Att glömma returtypen
En generisk funktion bör alltid ange vilken typ den returnerar. Annars kan TypeScript göra felaktiga antaganden, särskilt i mer komplexa kedjor av funktioner.
Att naming-konventionen blir otydlig
T är standard för en ensam typvariabel, men om du har flera typer kan det vara tydligare att använda namn som TData, TError eller TItem så att koden blir lättare att läsa.
Sammanfattning
TypeScript generics låter dig skriva kod som är både återanvändbar och typsäker. Oavsett om du bygger funktioner, klasser, gränssnitt eller API-klienter hjälper generics dig att undvika duplicerad kod och any, samtidigt som TypeScript fångar fel tidigt.
Börja smått: ersätt en any i din kodbas med en generisk typvariabel, och bygg därifrån.
Vanliga frågor
Måste jag använda bokstaven T?
Nej, T är bara en konvention. Du kan kalla typvariabeln vad du vill, men T är det vanligaste och det som de flesta utvecklare förväntar sig.
Kan jag ha flera typparametrar?
Ja, till exempel <T, U> låter dig arbeta med två olika typer samtidigt, vilket är användbart i funktioner som mappar mellan två typer.
Fungerar generics i JavaScript? Nej, generics är ett TypeScript-koncept. Koden kompileras bort till vanlig JavaScript, så det finns ingen körningstidskostnad.
När ska jag använda constraints?
När du behöver komma åt specifika egenskaper på den generiska typen, till exempel .length eller .map. Annars räcker det med en obegränsad typvariabel.
Relaterade artiklar

WebSocket för webbapplikationer – realtidskommunikation i webbläsaren
Lär dig hur WebSocket ger webbapplikationer tvåvägskommunikation i realtid, och hur du kommer igång med WebSocket API i JavaScript.
Läs artikeln
VS Code snippets – skapa egna kodsnuttar i Visual Studio Code
Spara tid i Visual Studio Code genom att skapa egna kodsnuttar. Vi visar hur du gör steg för steg.
Läs artikeln
Docker volymer – så sparar du data i containrar
Lär dig hur Docker volymer fungerar, skillnaden mellan namngivna volymer och bind mounts, och hur du sparar data även efter att containern är borttagen.
Läs artikeln
Docker Compose för webbutveckling – Enkel guide till att containerisera hela din stack
Lär dig hur Docker Compose används för att köra hela din webbutvecklingsstack lokalt med enkla docker-compose.yml-filer och kommandon.
Läs artikeln