Warum man Typen anstelle von Schnittstellen wählen sollte

In TypeScript werden sowohl Typen als auch Schnittstellen verwendet, um die Typen von Objekten zu definieren. Sie haben jedoch unterschiedliche Verwendungszwecke und Funktionen. Beides kann Entwicklern dabei helfen, die Typen von Variablen und Objekten beim Schreiben von Code einzuschränken, wodurch Fehler reduziert und die Lesbarkeit des Codes verbessert werden.

Warum also Typen? Lassen Sie uns das besprechen.

Typen

In TypeScript können Sie mit einem Typ die Form von Daten definieren. Es ist flexibel und kann zum Erstellen von Vereinigungen, Schnittpunkten und mehr verwendet werden.

type User = {
  name: string;
  age: number;
};

type Admin = User & {
  isAdmin: boolean;
};

Schnittstellen

Eine Schnittstelle ist eine weitere Möglichkeit, die Form eines Objekts zu definieren. Es ist starrer als Typen und wird hauptsächlich zum Definieren von Objektformen und Klassenverträgen verwendet.

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

interface Admin extends User {
  isAdmin: boolean;
}

Warum ich Typen bevorzuge

• Union

Mit Union-Typen können Sie einen Typ definieren, der einer von mehreren Typen sein kann. Dies ist praktisch für Funktionsparameter und Rückgabetypen. Hier kann ID entweder eine Zeichenfolge oder eine Zahl sein, was die Leistungsfähigkeit von Union-Typen demonstriert.

type ID = string | number;

function getUserId(id: ID): string {
  return `User ID: ${id}`;
}

• String-Literale

Mit Literaltypen können Sie genaue Werte angeben, die eine Variable haben kann. Dies kann sehr nützlich sein, um Konstanten oder Konfigurationsoptionen zu definieren.

type Direction = 'north' | 'south' | 'east' | 'west';

function move(direction: Direction) {
  console.log(`Moving ${direction}`);
}

move('north');

• Bedingte Typen

Typen ermöglichen die Erstellung von bedingten Typen und ermöglichen die Auswahl von Typen basierend auf Bedingungen

type Check<T> = T extends string ? string : number;

let result1: Check<string>; // result1 is of type string
let result2: Check<number>; // result2 is of type number

• Kreuzung

Mit Kreuzungstypen können Sie mehrere Typen zu einem kombinieren. Dies ist besonders nützlich für die Erstellung komplexer Schriftkompositionen.

type Person = {
  name: string;
  age: number;
};

type Employee = {
  employeeId: number;
};

type EmployeeDetails = Person & Employee;

const employee: EmployeeDetails = {
  name: 'Dev',
  age: 30,
  employeeId: 12345,
};

Die Wahl zwischen Typen und Schnittstellen hängt letztendlich von Ihrem spezifischen Anwendungsfall und Ihren persönlichen Vorlieben ab. Wenn Sie jedoch die Stärken jedes einzelnen verstehen, können Sie fundiertere Entscheidungen treffen und besseren TypeScript-Code schreiben.

Das obige ist der detaillierte Inhalt vonWarum man Typen anstelle von Schnittstellen wählen sollte. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!