🧬Generics

Generics sind Funktionen auf Typebene: Ein Typparameter wie T ist ein Platzhalter, den der Aufrufer (oder die Inferenz) mit einem echten Typ füllt. So bleibt Code wiederverwendbar, ohne Typinformation zu verlieren – anders als mit any.

  function verpacke<T>(wert: T): { wert: T }          Aufruf: verpacke(42)
                    │        │           │                             │
                    │        └───────────┼──── T wird aus dem Argument abgeleitet: T = number
                    ▼                    ▼
  Rückgabetyp:  { wert: T }   ──▶   { wert: number }

🎛️Typen einsetzen

Klicken Sie ein Argument an. Der Compiler setzt den passenden Typ für den Typparameter ein und berechnet den Ergebnistyp – oder meldet, warum es nicht passt.

Typparameter ableiten

<T> ist ein Platzhalter für einen Typ. Beim Aufruf setzt TypeScript für T den Typ des Arguments ein (Inferenz) – der Rückgabetyp folgt automatisch. Literale werden dabei verbreitert (1 | "eins" → string | number), außer man schreibt <const T>.

Argument:

function verpacke<T>(wert: T): { wert: T; zeit: number } {
  return { wert, zeit: Date.now() };
}
const ergebnis = verpacke(42);

function verpacke<T>(wert: T): { wert: T; zeit: number } {
  return { wert, zeit: Date.now() };
}
const ergebnis = verpacke(42);

ergebnis :…

Typargument explizit angeben

Man kann T auch selbst festlegen: verpacke<string>(…). Dann prüft der Compiler das Argument gegen diesen Typ.

Typargument:

function verpacke<T>(wert: T): { wert: T } {
  return { wert };
}
const ergebnis = verpacke<number>(42);

function verpacke<T>(wert: T): { wert: T } {
  return { wert };
}
const ergebnis = verpacke<number>(42);

ergebnis :…

Einschränkung mit extends

T extends { length: number } verlangt: Was auch immer T ist, es muss eine Eigenschaft length vom Typ number haben. Dadurch darf die Funktion x.length benutzen.

Argumente:

function laengstes<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}
const ergebnis = laengstes("Apfel", "Kiwi");

function laengstes<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}
const ergebnis = laengstes("Apfel", "Kiwi");

ergebnis :…

Schlüssel mit keyof

Zwei Typparameter, einer hängt vom anderen ab: K extends keyof T erlaubt nur existierende Schlüssel. Der Rückgabetyp T[K] ist der Typ genau dieser Eigenschaft.

Schlüssel:

function lies<T, K extends keyof T>(obj: T, schluessel: K): T[K] {
  return obj[schluessel];
}
const buch = { titel: "TypeScript", seiten: 320, verfuegbar: true };
const ergebnis = lies(buch, "titel");

function lies<T, K extends keyof T>(obj: T, schluessel: K): T[K] {
  return obj[schluessel];
}
const buch = { titel: "TypeScript", seiten: 320, verfuegbar: true };
const ergebnis = lies(buch, "titel");

ergebnis :…

Standard-Typen

Typparameter können einen Standardwert haben (T = unknown). Wird nichts angegeben, gilt der Standard – haben alle Parameter einen Standard, darf man die spitzen Klammern ganz weglassen. Beachten Sie: unknown | null ist einfach unknown.

Typargumente:

interface ApiAntwort<T = unknown, F = string> {
  daten: T | null;
  fehler: F | null;
}
type Ergebnis = ApiAntwort;

interface ApiAntwort<T = unknown, F = string> {
  daten: T | null;
  fehler: F | null;
}
type Ergebnis = ApiAntwort;

Ergebnis :…

📚Generische Klassen

Auch Klassen können Typparameter haben. new Stapel<number>() legt T für die ganze Instanz fest – lege("zwei") ist dann ein Fehler.

TypeScript · bearbeitbar, Maus über Namen zeigt Typen

class Stapel<T> {
  #elemente: T[] = [];
  lege(e: T): void {
    this.#elemente.push(e);
  }
  nimm(): T | undefined {
    return this.#elemente.pop();
  }
  get groesse(): number {
    return this.#elemente.length;
  }
}
const zahlen = new Stapel<number>();
zahlen.lege(1);
zahlen.lege("zwei");
const oben = zahlen.nimm();

JavaScript (erzeugt von tsc) · …nur lesen

// wird kompiliert …

// wird kompiliert …

💡 Namenskonventionen

T (Type), K/V (Key/Value), E (Element),R (Return). Bei mehreren Parametern helfen sprechende Namen wie TEingabe.

✅ Faustregel

Ein Typparameter lohnt sich, wenn er mindestens zweimal vorkommt – z. B. im Parameter und im Rückgabetyp. Kommt er nur einmal vor, reicht meist ein normaler Typ.

⚠️ Type Erasure gilt auch hier

Zur Laufzeit gibt es T nicht: new T() oder x instanceof T sind unmöglich. Wer den Typ zur Laufzeit braucht, übergibt eine Klasse oder eine Prüffunktion als Argument.