0Pricing
TypeScript Academy · Lektion

keyof und Indexed-Access-Typen

Greifen Sie mit keyof und T[K] dynamisch auf Eigenschaftstypen von Objekten zu.

keyof und Indexed-Access-Typen ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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

`keyof` erzeugt eine Union der Eigenschaftsnamen eines Objekttyps. Indexzugriffstypen (`T[K]`) rufen den Typ an einem bestimmten Eigenschaftsschlüssel ab.

Grundlagen von keyof

`keyof T` gibt eine Union aller Eigenschaftsnamentypen von T zurück.
interface User { id: number; name: string; email: string; }
type UserKeys = keyof User; // 'id' | 'name' | 'email'

Indexzugriff: T[K]

Verwenden Sie `T[K]`, um den Typ der Eigenschaft K im Typ T abzurufen.
type IdType = User['id'];   // number
type NameType = User['name']; // string

Dynamischer Eigenschaftszugriff

Kombinieren Sie `keyof` und Generics, um typsichere Funktionen für den Eigenschaftszugriff zu erstellen.
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const name = getProperty(user, 'name'); // string

keyof mit typeof

Verwenden Sie `typeof` auf einem Wert und anschließend `keyof`, um dessen Eigenschaftsnamen ohne die Deklaration eines Interfaces abzurufen.
const config = { host: 'localhost', port: 3000 };
type ConfigKey = keyof typeof config; // 'host' | 'port'

Union von Indexzugriffstypen

Indizieren Sie einen Typ mit einer Union von Schlüsseln, um die Union ihrer Werttypen abzurufen.
type NumericValues = User['id' | 'age']; // number | number = number

keyof für Arrays

`keyof` für einen Arraytyp gibt neben den Namen der Array-Methoden auch Array-Indextypen zurück.
type ArrKey = keyof string[]; // number | 'length' | 'push' | ...
type Element = string[][number]; // string

Rekursiver Indexzugriff

Verketten Sie Indexzugriffstypen für verschachtelte Objekte.
type Address = { city: string; zip: string };
type Profile = { address: Address };
type City = Profile['address']['city']; // string

Einschränkungen mit keyof

Verwenden Sie `K extends keyof T` als generische Einschränkung, um sicherzustellen, dass K ein gültiger Schlüssel von T ist.
function setProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]): void {
  obj[key] = value;
}

Mapped Types verwenden keyof

Mapped Types durchlaufen `keyof T`, um Objekttypen zu transformieren.
type Readonly2<T> = { readonly [K in keyof T]: T[K] };

keyof in bedingten Typen

`keyof` ist in bedingten Typen besonders leistungsfähig, wenn bestimmte Schlüsselgruppen extrahiert werden sollen.
type StringKeys<T> = { [K in keyof T]: T[K] extends string ? K : never }[keyof T];

Kurztest

Was gibt `User['name']` zurück, wenn `interface User { name: string }` definiert ist?

Zusammenfassung

`keyof` extrahiert Eigenschaftsnamen als Union-Typ. `T[K]` ruft den Typ an einem Schlüssel ab. Zusammen ermöglichen sie typsicheren Eigenschaftszugriff, Mapped Types und Hilfstypen für bedingte Typen.

Häufig gestellte Fragen

Ist die Lektion „keyof und Indexed-Access-Typen“ kostenlos?

Ja — der vollständige Text von „keyof und Indexed-Access-Typen“ 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 „keyof und Indexed-Access-Typen“?

Greifen Sie mit keyof und T[K] dynamisch auf Eigenschaftstypen von Objekten zu. 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 1 von 4.

Wie lange dauert die Lektion „keyof und Indexed-Access-Typen“?

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

  1. keyof und Indexed-Access-Typen
  2. Generische Einschränkungen: Typparameter eingrenzen
  3. Bedingte Typen: T extends U ? X : Y
  4. Distributive bedingte Typen
← Zurück zu TypeScript Academy