Wie man ein TypeScript-Vorstellungsgespräch besteht: Top-Fragen von A bis Z

Einleitung: Warum TypeScript ein Must-have für moderne Entwickler ist

TypeScript hat sich als De-facto-Standard in der Enterprise-Entwicklung etabliert. Laut Stack Overflow-Umfragen verwenden oder planen über 70 % der Frontend-Entwickler, TypeScript zu nutzen. In Vorstellungsgesprächen sind Fragen zu dieser Technologie unvermeidlich – selbst wenn die Stelle formal als "JavaScript Developer" ausgeschrieben ist.

In diesem Artikel behandeln wir die wichtigsten Themen, die Ihnen im technischen Interview mit Sicherheit gestellt werden: von grundlegenden Typen bis hin zu komplexen Generics und bedingten Typen. Das Material ist nach dem Prinzip "vom Einfachen zum Komplexen" aufgebaut, damit Sie sich systematisch vorbereiten können.

1. Grundlagen: Typen, Interfaces und ihre Unterschiede

1.1. Primitive und spezielle Typen

Beginnen wir mit den Grundlagen. Der Interviewer wird Sie fast sicher nach any, unknown, never und void fragen.

• any – deaktiviert die Typprüfung. Wird nur als letztes Mittel bei der Migration verwendet.
• unknown – eine sichere Alternative zu any. Erfordert eine Typprüfung vor der Verwendung.
• never – ein Typ, der niemals eintritt (Funktionen, die Ausnahmen auslösen, oder Endlosschleifen).
• void – das Fehlen eines Rückgabewerts einer Funktion.

function throwError(msg: string): never {    throw new Error(msg);}

function log(msg: string): void {    console.log(msg);}

let data: unknown = JSON.parse('{"name":"John"}');// data.name // Fehler! Eine Prüfung ist erforderlichif (typeof data === 'object' && data !== null) {    console.log((data as Record<string, unknown>).name);}

1.2. Interface vs Type: Was wählen?

Das ist eine klassische Frage. Beide Ansätze ermöglichen die Beschreibung der Struktur eines Objekts, aber es gibt Nuancen:

• Interface – erweiterbar (extends), kann zusammengeführt werden (declaration merging).
• Type – kann Union-Typen, Intersection-Typen und Primitive beschreiben. Unterliegt keinem declaration merging.

// Interface - Erweiterunginterface User {    name: string;}interface User {    age: number; // declaration merging}const user: User = { name: 'Alice', age: 30 };

// Type - Uniontype Status = 'active' | 'inactive';type UserOrStatus = User | Status;

Tipp: Verwenden Sie für Objekte und Klassen interface, für komplexe Kompositionen type.

2. Generics und Utility-Typen

2.1. Generics: Generische Programmierung

Kein ernsthaftes Interview kommt ohne Generics aus. Die Fähigkeit, einen Typ zu schreiben, der sich an das übergebene Argument anpasst, ist ein Zeichen für die Reife eines Entwicklers.

// Einfaches Genericfunction identity<T>(arg: T): T {    return arg;}

// Generic mit Einschränkungfunction getLength<T extends { length: number }>(arg: T): number {    return arg.length;}

// Generic für Arraysfunction last<T>(arr: T[]): T | undefined {    return arr[arr.length - 1];}

Häufig wird nach infer gefragt – dem Schlüsselwort zur Typableitung innerhalb bedingter Konstrukte:

// Extrahiere den Elementtyp aus Promisetype Unwrap<T> = T extends Promise<infer U> ? U : T;type Result = Unwrap<Promise<number>>; // number

2.2. Utility-Typen

Die Kenntnis der integrierten Hilfstypen ist ein absolutes Minimum. Der Interviewer könnte Sie bitten, eine Entsprechung manuell zu implementieren.

• Partial<T> – alle Felder werden optional.
• Required<T> – alle Felder sind erforderlich.
• Pick<T, K> – wählt nur die angegebenen Schlüssel aus.
• Omit<T, K> – schließt die angegebenen Schlüssel aus.