TypeScript: Objekte, Interfaces und Typ-Aliase

Kurz: Der Typ eines Objekts beschreibt, welche Eigenschaften es hat:

Teil des Kurses TypeScript

Kapitel 4 von 15 im Kurs TypeScript (Abschnitt „Typen beschreiben“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

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");

Ausgabe:

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;

Fehlermeldung:

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);

Ausgabe:

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 };

Fehlermeldung:

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 y

Ausgabe:

5

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);

Ausgabe:

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);

Ausgabe:

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");

Ausgabe:

[info] gestartet
[fehler] 500 kaputt

Merke

• Objekttypen beschreiben Eigenschaften: name: string, optional x?: T, schreibgeschützt readonly
• interface und type sind für Objekte fast austauschbar; type kann 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

Übungsaufgabe

Beschreibe mit Interfaces einen Blog: Autor, Beitrag (mit Autor und Tags) und eine Funktion, die den Titel des Beitrags mit dem Autornamen ausgibt.

Quiz zur Selbstkontrolle

Wie markierst du eine nur lesbare Eigenschaft?

• readonly (richtig)
• const
• final
• static

Was bedeutet strukturelle Typisierung?

• Es zählt die Form des Objekts, nicht der Typname (richtig)
• Typen müssen denselben Namen haben
• Es gibt nur eine Struktur
• Typen sind Klassen

Wie kombinierst du zwei Typen zu einem?

• mit & (Schnittmenge) (richtig)
• mit +
• mit ,
• mit ::

Weiter im Kurs

Zurück: Funktionen mit Typen

Weiter: Unions, Literaltypen und Narrowing

Alle Kapitel: TypeScript im Überblick