In TypeScript sind Schnittstellen ein leistungsstarkes Werkzeug zum Definieren der Form eines Objekts. Sie erzwingen die Typprüfung und stellen sicher, dass die von Ihnen erstellten Objekte einer bestimmten Struktur entsprechen. Hier sehen Sie verschiedene Fälle, in denen Schnittstellen häufig verwendet werden, zusammen mit Beispielen:

1. Objektform definieren

Schnittstellen werden häufig verwendet, um die Struktur eines Objekts zu definieren. Dadurch wird sichergestellt, dass jedes Objekt, das an der Schnittstelle haftet, über bestimmte Eigenschaften verfügt.

interface User {
  name: string;
  age: number;
  email: string;
}

const user: User = {
  name: "John Doe",
  age: 30,
  email: "[email protected]"
};

2. Optionale Eigenschaften

Schnittstellen ermöglichen Ihnen die Definition optionaler Eigenschaften mithilfe des ? Symbol. Das bedeutet, dass das Objekt diese Eigenschaften haben kann oder nicht.

interface Product {
  id: number;
  name: string;
  description?: string; // Optional property
}

const product: Product = {
  id: 1,
  name: "Laptop"
};

3. Schreibgeschützte Eigenschaften

Sie können Eigenschaften als schreibgeschützt definieren, was bedeutet, dass sie nach der Initialisierung nicht geändert werden können.

interface Config {
  readonly apiUrl: string;
  timeout: number;
}

const config: Config = {
  apiUrl: "https://api.example.com",
  timeout: 5000
};

// config.apiUrl = "https://newapi.example.com"; // Error: Cannot assign to 'apiUrl' because it is a read-only property.

4. Funktionstypen

Schnittstellen können verwendet werden, um die Form von Funktionen zu definieren und die Parametertypen und den Rückgabetyp anzugeben.

interface Login {
  (username: string, password: string): boolean;
}

const login: Login = (username, password) => {
  return username === "admin" && password === "admin123";
};

console.log(login("admin", "admin123")); // true

5. Schnittstellen erweitern

Schnittstellen können andere Schnittstellen erweitern und ermöglichen die Erstellung komplexer Typen durch die Kombination bestehender.

interface Person {
  name: string;
  age: number;
}

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

const employee: Employee = {
  name: "Alice",
  age: 28,
  employeeId: 12345,
  department: "Engineering"
};

6. Interfaces in Klassen implementieren

Klassen können Schnittstellen implementieren und so sicherstellen, dass sie sich an die Struktur der Schnittstelle halten.

interface Animal {
  name: string;
  makeSound(): void;
}

class Dog implements Animal {
  name: string;

  constructor(name: string) {
    this.name = name;
  }

  makeSound() {
    console.log("Woof! Woof!");
  }
}

const dog = new Dog("Buddy");
dog.makeSound(); // Woof! Woof!

7. Indexierbare Typen

Schnittstellen können Objekte beschreiben, die Eigenschaften mit dynamischen Schlüsseln eines bestimmten Typs haben.

interface StringArray {
  [index: number]: string;
}

const myArray: StringArray = ["Hello", "World"];
console.log(myArray[0]); // Hello

8. Hybridtypen

Schnittstellen können Objekte definieren, die sowohl als Funktion als auch als Objekt mit Eigenschaften fungieren.

interface Counter {
  (start: number): void;
  interval: number;
  reset(): void;
}

const counter: Counter = (function (start: number) {
  console.log("Counter started at", start);
} as Counter);

counter.interval = 1000;
counter.reset = () => {
  console.log("Counter reset");
};

counter(10);
console.log(counter.interval); // 1000
counter.reset();

9. Schnittstellenzusammenführung

TypeScript ermöglicht Ihnen das Zusammenführen mehrerer Deklarationen derselben Schnittstelle, was bei der Arbeit mit großen Codebasen oder Bibliotheken nützlich ist.

interface Box {
  height: number;
  width: number;
}

interface Box {
  color: string;
}

const myBox: Box = {
  height: 20,
  width: 15,
  color: "blue"
};

Schnittstellen in TypeScript bieten eine flexible und leistungsstarke Möglichkeit, Objektformen zu definieren und durchzusetzen und ermöglichen so eine starke Typprüfung und klaren, wartbaren Code.