Generics

Willkommen in der nächsten Lektion! In dieser Lektion lernen Sie Generics kennen, ein leistungsstarkes Feature in TypeScript, mit dem Sie wiederverwendbare und typsichere Komponenten erstellen können. Beginnen wir!

Was sind Generics?

Mit Generics können Sie wiederverwendbaren Code schreiben, der mit jedem Typ funktioniert. Sie dienen als Platzhalter für Typen, die Sie bei ihrer Verwendung festlegen können.

Beispiel: Eine generische Funktion:

Aufgabe: Schreiben Sie eine generische Funktion, die ein Argument entgegennimmt und unverändert zurückgibt.

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

console.log(identity<string>("Hello")); 
// Output: Hello
console.log(identity<number>(42)); 
// Output: 42

Warum Generics verwenden?

Generics helfen Ihnen dabei:

• Wiederverwendbaren Code zu schreiben: Funktionen und Klassen können mit unterschiedlichen Typen arbeiten.
• Typsicherheit zu gewährleisten: Sie können bestimmte Typen erzwingen, ohne Flexibilität einzubüßen.
• Redundanz zu reduzieren: Vermeiden Sie es, für unterschiedliche Typen separate Versionen derselben Funktion oder Klasse zu schreiben.

Tipp: Verwenden Sie Generics, um flexibleren und besser wartbaren Code zu schreiben.

Generische Funktionen

Sie können Generics verwenden, um flexible Funktionen zu erstellen. Beispiel:

Aufgabe: Schreiben Sie eine generische Funktion, die zwei Objekte zusammenführt und das Ergebnis zurückgibt.

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

let merged = merge({ name: "Alice" }, { age: 25 });
console.log(merged); 
// Output: { name: "Alice", age: 25 }

Generische Klassen

Generics können in Klassen verwendet werden, damit diese für unterschiedliche Typen wiederverwendbar sind. Beispiel:

class Box<T> {
  private contents: T;

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

  getContents(): T {
    return this.contents;
  }
}

let stringBox = new Box<string>("Hello");
console.log(stringBox.getContents()); 
// Output: Hello

let numberBox = new Box<number>(42);
console.log(numberBox.getContents()); 
// Output: 42

Generische Interfaces

Interfaces können ebenfalls Generics verwenden, um die Struktur für unterschiedliche Typen zu erzwingen. Beispiel:

Aufgabe: Definieren Sie ein generisches Interface und erstellen Sie ein Objekt, das es implementiert.

interface Pair<T, U> {
  first: T;
  second: U;
}

let coordinates: Pair<number, number> = { first: 10, second: 20 };
console.log(coordinates); 
// Output: { first: 10, second: 20 }

Einschränkungen für Generics

Sie können Generics Einschränkungen hinzufügen, damit sie nur mit bestimmten Typen funktionieren. Beispiel:

function printLength<T extends { length: number }>(item: T): void {
  console.log(`Length: ${item.length}`);
}

printLength("Hello"); 
// Output: Length: 5
printLength([1, 2, 3]); 
// Output: Length: 3
// printLength(42); 
// Error: Argument of type 'number' is not assignable to parameter of type '{ length: number }'.

Standardwerte für Generics

Sie können Standardtypen für Generics angeben, wenn kein Typ bereitgestellt wird. Beispiel:

Aufgabe: Erstellen Sie eine generische Funktion mit einem Standardtyp und testen Sie sie mit unterschiedlichen Typen.

function wrap<T = string>(value: T): T[] {
  return [value];
}

console.log(wrap("Hello")); // Output: ["Hello"]
console.log(wrap(42)); // Output: [42]

Sehr gut gemacht!

Herzlichen Glückwunsch! Sie haben gelernt, wie Sie Generics in TypeScript verwenden, um wiederverwendbare und typsichere Funktionen, Klassen und Interfaces zu erstellen. Generics sind ein leistungsstarkes Werkzeug zum Schreiben von flexiblem und skalierbarem Code. In der nächsten Lektion beschäftigen wir uns mit fortgeschrittenen Typen wie gemappten und bedingten Typen. Programmieren wir weiter!