Objekttypen
Der Typ eines Objekts beschreibt, welche Eigenschaften es hat:
type Nutzer = {
id: number;
name: string;
email?: string; // optional
readonly angelegt: string; // nur lesbar
};
const mia: Nutzer = { id: 1, name: "Mia", angelegt: "2025-01-01" };
console.log(mia.name, mia.email ?? "keine E-Mail");Mia keine E-Mail
type Nutzer = { id: number; name: string; readonly angelegt: string };
const mia: Nutzer = { id: 1, name: "Mia", angelegt: "2025" };
mia.angelegt = "2026";
mia.alter = 17;error TS2540: Cannot assign to 'angelegt' because it is a read-only property.
interface oder type?
Es gibt zwei Schreibweisen für Objektformen. Meist sind sie austauschbar:
interface Tier {
name: string;
laut(): string;
}
interface Hund extends Tier { // Interfaces erweitern andere
rasse: string;
}
type Katze = Tier & { farbe: string }; // Typ-Aliase kombinieren mit &
const rex: Hund = { name: "Rex", rasse: "Schäfer", laut: () => "Wuff" };
const mimi: Katze = { name: "Mimi", farbe: "grau", laut: () => "Miau" };
console.log(rex.laut(), mimi.laut(), rex.rasse, mimi.farbe);Wuff Miau Schäfer grau
interface | type | |
|---|---|---|
| Objekte beschreiben | ja | ja |
| Erweitern | extends | & (Schnittmenge) |
| Zusammenführen bei gleichem Namen | ja (declaration merging) | nein |
| Unions, Tupel, einfache Typen | nein | ja |
Von Klassen umsetzbar (implements) | ja | ja (Objekttypen) |
Faustregel: interface für Objekte und öffentliche Schnittstellen, type für alles andere (Unions, Tupel, Hilfstypen). Wichtig ist, im Projekt einheitlich zu bleiben.
Überschüssige Eigenschaften
Bei Objektliteralen prüft TypeScript auf Tippfehler:
interface Punkt { x: number; y: number }
const p: Punkt = { x: 1, y: 2, z: 3 };error TS2353: Object literal may only specify known properties, and 'z' does not exist in type 'Punkt'.
Wird das Objekt zuerst in eine Variable gelegt, ist es erlaubt (strukturelle Typisierung): Es zählt nur, ob alle benötigten Eigenschaften vorhanden sind.
interface Punkt { x: number; y: number }
function laenge(p: Punkt): number { return Math.hypot(p.x, p.y); }
const dreiD = { x: 3, y: 4, z: 5 };
console.log(laenge(dreiD)); // passt: hat x und y5
Index-Signaturen und Record
Für Objekte mit beliebigen Schlüsseln:
const preise: { [artikel: string]: number } = { apfel: 1.2, birne: 1.5 };
const alter: Record<string, number> = { Mia: 17, Tom: 19 }; // kürzer
alter["Zoe"] = 21;
console.log(preise.apfel, Object.keys(alter).length);1.2 3
Verschachtelte und wiederverwendbare Typen
interface Adresse { stadt: string; plz: string }
interface Kunde {
name: string;
adresse: Adresse;
bestellungen: { id: number; summe: number }[];
}
const k: Kunde = { name: "Mia", adresse: { stadt: "Köln", plz: "50667" }, bestellungen: [{ id: 1, summe: 20 }] };
console.log(k.adresse.stadt, k.bestellungen.length);
type Bestellung = Kunde["bestellungen"][number]; // Typ aus anderem Typ ableiten
const b: Bestellung = { id: 2, summe: 5 };
console.log(b.id);Köln 1 2
Funktionen in Interfaces
interface Logger {
info(text: string): void;
fehler: (text: string, code?: number) => void;
}
const konsole: Logger = {
info: (t) => console.log("[info]", t),
fehler: (t, c = 500) => console.log("[fehler]", c, t),
};
konsole.info("gestartet");
konsole.fehler("kaputt");[info] gestartet [fehler] 500 kaputt
Merke
- Objekttypen beschreiben Eigenschaften:
name: string, optionalx?: T, schreibgeschütztreadonly interfaceundtypesind für Objekte fast austauschbar;typekann zusätzlich Unions und Tupel- Erweitern:
extends(interface) oder&(type) - TypeScript ist strukturell: Es zählt die Form, nicht der Name
Record<string, T>und Index-Signaturen für beliebige Schlüssel
Aufgabe
Beschreibe mit Interfaces einen Blog: Autor, Beitrag (mit Autor und Tags) und eine Funktion, die den Titel des Beitrags mit dem Autornamen ausgibt.