TypeScript Academy · Lektion

Generische Einschränkungen mit extends

Beschränken Sie Typparameter auf bestimmte Strukturen.

Generische Einschränkungen mit extends ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Generische Typbeschränkungen schränken ein, welche Typen als Typargumente übergeben werden können. Verwenden Sie `extends`, um zu verlangen, dass T bestimmte Eigenschaften besitzt oder einer bestimmten Struktur entspricht.

Das Problem ohne Beschränkungen

Ohne Beschränkungen weiß TypeScript nicht, welche Operationen für T gültig sind, und erlaubt daher nur Operationen, die allen Typen gemeinsam sind.

function getLength<T>(val: T): number {
  // return val.length; // Error — T might not have .length
}

Eine Beschränkung hinzufügen

Verwenden Sie `T extends Shape`, um zu verlangen, dass T mindestens die Eigenschaften von Shape besitzt.

function getLength<T extends { length: number }>(val: T): number {
  return val.length;
}
getLength('hello');  // OK — string has .length
getLength([1, 2]);   // OK — array has .length
// getLength(42);   // Error — number has no .length

Auf ein Interface beschränken

Beschränken Sie T darauf, ein bestimmtes Interface zu implementieren.

interface Named { name: string; }
function greet<T extends Named>(person: T): string {
  return 'Hello, ' + person.name;
}

keyof-Beschränkung

Verwenden Sie `K extends keyof T`, um K auf die Schlüssel von T zu beschränken. Dadurch wird ein sicherer Zugriff auf Eigenschaften ermöglicht.

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const age = getProperty({ name: 'Alice', age: 30 }, 'age'); // number

Eine Union erweitern

T kann auf einen Union-Typ beschränkt werden, sodass das Typargument nur bestimmte Werte annehmen darf.

type Status = 'active' | 'inactive' | 'banned';
function setStatus<T extends Status>(status: T): void {
  console.log('Setting status:', status);
}

Auf einen Konstruktor beschränken

Beschränken Sie T darauf, eine Klasse zu sein, also einen Konstruktor zu besitzen, damit Sie innerhalb der Funktion Instanzen erstellen können.

function create<T>(ctor: new () => T): T {
  return new ctor();
}

Mehrere Beschränkungen mit Intersection

Beschränken Sie T mithilfe einer Intersection darauf, mehrere Interfaces zu erfüllen.

interface Serializable { serialize(): string; }
interface Loggable { log(): void; }
function process<T extends Serializable & Loggable>(item: T): void {
  item.log();
  console.log(item.serialize());
}

Vererbung von Beschränkungen

Beschränkungen funktionieren mit Vererbung. Wenn T eine Basisklasse erweitert, können Sie alle Methoden der Basisklasse aufrufen.

class Animal { breathe() { return 'breathing'; } }
function care<T extends Animal>(a: T): string { return a.breathe(); }

T erweitert sich selbst (rekursiv)

Beschränkungen können für rekursive Datenstrukturen auf sich selbst verweisen.

interface Comparable<T> { compareTo(other: T): number; }
function max<T extends Comparable<T>>(a: T, b: T): T {
  return a.compareTo(b) >= 0 ? a : b;
}

Fehlermeldungen bei Beschränkungen

Wenn ein Typargument eine Beschränkung nicht erfüllt, meldet TypeScript einen eindeutigen Fehler, der sowohl das Argument als auch die Beschränkung nennt.

Kurztest

Worauf beschränkt `K extends keyof T` K?

Zusammenfassung

Verwenden Sie `T extends SomeType`, um generische Typparameter zu beschränken. Dadurch können Sie bestimmte Methoden auf T aufrufen, keyof für einen sicheren Zugriff auf Eigenschaften verwenden und typsichere Hilfsfunktionen erstellen.

Häufig gestellte Fragen

Ist die Lektion „Generische Einschränkungen mit extends“ kostenlos?

Ja — der vollständige Text von „Generische Einschränkungen mit extends“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Generische Einschränkungen mit extends“?

Beschränken Sie Typparameter auf bestimmte Strukturen. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Generische Einschränkungen mit extends“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu TypeScript Academy