# TypeScript generics – återanvändbar och typsäker kod

*Robert Roos*
*21 november 2026*

> Lär dig hur TypeScript generics låter dig skriva kod som fungerar med många typer utan att förlora typsäkerheten. En steg-för-steg guide för utvecklare.

# 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:

```typescript
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:

```typescript
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.

```typescript
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:

```typescript
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:

```typescript
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.
