Wann sollte man in TypeScript Typen und wann Schnittstellen verwenden?

Die Typen (type) sollten verwendet werden für:

• Vereinigungen (unions) und Schnittmengen (intersections):

  type Status = "pending" | "completed" | "failed";
  type UserWithAddress = User & Address;
  

• Primitive Typen und Literale:

  type ID = string | number;
  type Direction = "up" | "down" | "left" | "right";
  

• Tupel:

  type RgbColor = [number, number, number];
  

• Erstellung von Aliasen für bestehende Typen:

  type StringOrNumber = string | number;
  

• Bedingte Typen:

  type TypeOfProp<T, K extends keyof T> = T[K];
  

Interfaces (interface) sollten verwendet werden für:

• Beschreibung der Objektstruktur:

  interface User {
    id: number;
    name: string;
    age?: number; // Optionale Eigenschaft
  }
  

• Implementierung durch Klassen (implements):

  interface Logger {
    log(message: string): void;
  }
  
  class ConsoleLogger implements Logger {
    log(message: string) {
      console.log(message);
    }
  }
  

• Erweiterung anderer Interfaces (extends):

  interface Person {
    name: string;
  }
  
  interface Employee extends Person {
    employeeId: number;
  }
  

• Deklaratives Zusammenführen (declaration merging): Dies erlaubt es, eine bestehende Schnittstelle durch erneutes Deklarieren zu erweitern. Bei Typen ist dies nicht möglich.

  interface Box {
    width: number;
  }
  
  interface Box { // Dies fügt die Eigenschaft height zur Schnittstelle Box hinzu
    height: number;
  }
  

Kurzer Vergleich:

Eigenschaft	type	interface
Vereinigungstypen	Ja	Nein
Schnittmengen	Ja	Nein
Primitive Typen/Literale	Ja	Nein
Tupel	Ja	Nein
Alias für Typen	Ja	Nein
Bedingte Typen	Ja	Nein
Objektbeschreibung	Ja	Ja
Klassenimplementierung	Nein	Ja
Erweiterung	Ja (mit &)	Ja (mit extends)
Deklaratives Zusammenführen	Nein	Ja

Im Allgemeinen ist es besser, interface zu verwenden, um die Objektstruktur zu beschreiben, da sie besser zum objektorientierten Ansatz passt und deklaratives Zusammenführen unterstützt. Für alles andere, insbesondere für Kombinationen und das Erstellen neuer Typen aus bestehenden, ist type flexibler.