TypeScript Academy · Lektion

Indexzugriffstypen

Ermitteln Sie Eigenschaftstypen mit der Syntax T[K].

Indexzugriffstypen 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.

Eigenschaftstypen nachschlagen

Mit indizierten Zugriffstypen können Sie den Typ einer Eigenschaft mithilfe der Klammersyntax an einer Typposition nachschlagen: Obj['prop']. Das entspricht dem Lesen eines Werts, findet aber auf Typebene statt.

Grundlagen des indizierten Zugriffs

Indizieren Sie einen Typ mit einem Literalschlüssel, um den Typ dieser Eigenschaft zu extrahieren. User['name'] ergibt string.

interface User { id: number; name: string }
type NameType = User["name"] // string
const n: NameType = "Ada"
console.log(n)

Warum den Typ nicht einfach ausschreiben

Indizierter Zugriff hält Typen synchron. Wenn sich User.name von string in etwas anderes ändert, werden alle Vorkommen von User['name'] automatisch aktualisiert – ohne manuelle Änderungen.

interface Product { price: { amount: number; currency: string } }
type Price = Product["price"] // { amount: number; currency: string }
const p: Price = { amount: 10, currency: "USD" }
console.log(p)

Zugriff mit einer Schlüssel-Union

Indizieren Sie mit einer Schlüssel-Union, um eine Union der zugehörigen Werttypen zu erhalten. User['id' | 'name'] ergibt number | string.

interface User { id: number; name: string }
type IdOrName = User["id" | "name"] // number | string
const v: IdOrName = 5
console.log(v)

Obj[keyof Obj] für alle Werte

Indizieren Sie mit keyof Obj, um eine Union aller Werttypen im Objekt zu erhalten – die vollständige Menge seiner Werttypen.

interface Config { host: string; port: number; secure: boolean }
type Values = Config[keyof Config] // string | number | boolean
const v: Values = true
console.log(v)

Array-Elementtyp mit [number]

Bei einem Arraytyp indizieren Sie mit number, um seinen Elementtyp zu erhalten. string[][number] ist string.

type Names = string[]
type Item = Names[number] // string
const x: Item = "Ada"
console.log(x)

Elementtyp eines Tupels

Das Indizieren eines Tupels mit number ergibt die Union aller seiner Elementtypen – nützlich, um aus einer festen Liste einen Werttyp abzuleiten.

type Pair = [string, number]
type Element = Pair[number] // string | number
const e: Element = 42
console.log(e)

Mit typeof kombinieren

Greifen Sie über typeof auf den Typ eines Werts zu. Zusammen mit [number] bei einem as const-Array leitet dies eine Union der Literalwerte des Arrays ab.

const colors = ["red", "green", "blue"] as const
type Color = typeof colors[number] // "red" | "green" | "blue"
const c: Color = "green"
console.log(c)

Verschachtelter Indexed Access

Verketten Sie Zugriffe, um in verschachtelte Typen vorzudringen. Jede Klammer steigt eine Ebene in der Struktur hinab.

interface Data { user: { profile: { age: number } } }
type Age = Data["user"]["profile"]["age"] // number
const a: Age = 36
console.log(a)

Indexed Access in Generics

Das Muster T[K] mit K extends keyof T bildet die Grundlage typsicherer Getter: Der Rückgabetyp entspricht genau dem Typ der abgerufenen Eigenschaft.

function get<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key]
}
const port = get({ host: "x", port: 80 }, "port")
console.log(port) // 80, typed as number

Eine praktische Ableitung

Indexed Access vermeidet doppelte Typdefinitionen: Leiten Sie den Typ eines Funktionsarguments direkt aus einem Domänenobjekt ab, statt ihn erneut anzugeben.

interface Order { items: { sku: string; qty: number }[] }
type LineItem = Order["items"][number] // { sku: string; qty: number }
const li: LineItem = { sku: "A1", qty: 2 }
console.log(li)

Kurzer Check

Testen Sie Ihr Verständnis von Indexed-Access-Typen.

Zusammenfassung

Indexed-Access-Typen (Obj['prop']) rufen den Typ einer Eigenschaft ab und bleiben dabei mit der Quelle synchron. Verwenden Sie eine Union von Schlüsseln als Index, um eine Union von Werttypen zu erhalten, keyof Obj für alle Werte und number für die Elementtypen von Arrays oder Tupeln. Verketten Sie Klammern für verschachtelte Zugriffe und kombinieren Sie Indexed Access mit typeof und Generics (T[K]) für typsichere Ableitungen.

Häufig gestellte Fragen

Ist die Lektion „Indexzugriffstypen“ kostenlos?

Ja — der vollständige Text von „Indexzugriffstypen“ 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 „Indexzugriffstypen“?

Ermitteln Sie Eigenschaftstypen mit der Syntax T[K]. 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 „Indexzugriffstypen“?

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