Generics in TypeScript

Generics, oder parametrisierte Typen, sind ein zentrales Konzept in TypeScript, das wesentlich zur Verbesserung der Wiederverwendbarkeit und Typsicherheit von Code beiträgt. Durch die Verwendung von Generics können Sie Komponenten erstellen, die mit mehreren Typen arbeiten können, anstatt auf einen einzelnen Typ beschränkt zu sein.

24.1 Generics in Funktionen

Generics in Funktionen ermöglichen es Ihnen, Funktionen zu definieren, die mit verschiedenen Typen arbeiten können, ohne dabei die Typsicherheit zu verlieren. Hier ist ein erweitertes Beispiel, das zeigt, wie eine generische Funktion erstellt wird:

function createArray<T>(length: number, value: T): Array<T> {
  let result: T[] = [];
  for (let i = 0; i < length; i++) {
    result.push(value);
  }
  return result;
}

let numbers = createArray<number>(3, 0);  // [0, 0, 0]
let strings = createArray<string>(3, 'a');  // ['a', 'a', 'a']

24.1.1 Generics mit mehreren Typen

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

let mergedObj = merge({ name: 'John' }, { age: 30 });  // { name: 'John', age: 30 }

Hier kombiniert die merge-Funktion zwei Objekte unterschiedlicher Typen in ein einzelnes Objekt.

24.2 Generics in Klassen

Generics erhöhen die Flexibilität von Klassen, indem sie es ermöglichen, Typen als Parameter zu verwenden:

class Box<T> {
  private content: T;

  constructor(content: T) {
    this.content = content;
  }

  getContent(): T {
    return this.content;
  }
}

let numberBox = new Box<number>(100);
let stringBox = new Box<string>('hello');

24.2.1 Generische Klassen mit mehreren Typen

Generics können auch verwendet werden, um Klassen mit mehreren Typenparametern zu definieren:

class Pair<K, V> {
  constructor(public key: K, public value: V) {}

  getKey(): K {
    return this.key;
  }

  getValue(): V {
    return this.value;
  }
}

let pair = new Pair<string, number>('age', 30);

24.3 Generics in Interfaces

Generics erweitern die Anwendbarkeit von Interfaces, indem sie variierende Typen unterstützen:

interface KeyValuePair<K, V> {
  key: K;
  value: V;
}

let kv1: KeyValuePair<number, string> = { key: 1, value: "Steve" };
let kv2: KeyValuePair<string, boolean> = { key: "isActive", value: true };

24.3.1 Interfaces als Funktionstypen

interface Transform<T, U> {
  (value: T): U;
}

const stringToNumber: Transform<string, number> = (value) => parseInt(value);

Generics sind ein ungemein mächtiges Werkzeug in TypeScript, das es ermöglicht, wiederverwendbare und typsichere Komponenten wie Funktionen, Klassen und Interfaces zu erstellen. Sie erhöhen die Flexibilität Ihres Codes, ohne Kompromisse bei der Typsicherheit einzugehen.

24 Generics in TypeScript