TypeScript Interviewfragen und Antworten (25 mit Code)

Das sind die TypeScript-Fragen, die in Interviews am häufigsten gestellt werden, mit der kurzen Antwort, die du geben können solltest, und einem kleinen Beispiel. Sie sind nach Niveau gruppiert; bei einer Junior-Stelle ist meist nach der ersten Gruppe Schluss, bei einer Senior-Stelle wird erwartet, dass du die Typen der letzten Gruppe aus dem Kopf schreibst.

Fragen für Einsteiger

1. Was ist TypeScript?

TypeScript ist JavaScript mit statischen Typen, entwickelt von Microsoft. Du annotierst Werte mit Typen, der Compiler prüft sie, entfernt die Typen dann und gibt reines JavaScript aus, das überall läuft, wo JavaScript läuft.

function add(a: number, b: number): number {
  return a + b;
}

console.log(add(2, 3)); // 5

// @ts-expect-error Argument of type 'string' is not assignable to parameter of type 'number'.
const wrong = add("2", 3);
console.log(wrong); // 23: the call was forced through, and JavaScript concatenated

Ohne den Kommentar @ts-expect-error ist der zweite Aufruf ein Compilerfehler, der Bug geht also nie in Produktion.

2. Prüft TypeScript Typen zur Laufzeit?

Nein. Typen werden beim Kompilieren entfernt; in der Ausgabe ist keine Spur von ihnen. Der Lauf oben gibt 23 aus, weil zur Laufzeit nichts weiß, dass a eine Zahl sein sollte. Um Daten von außerhalb des Programms zu prüfen (JSON, Benutzereingaben, API-Antworten), schreibst du echte Prüfungen, etwa einen Type Guard oder einen Schema-Validator.

3. Was sind die Grundtypen?

string, number (ein Typ für ganze Zahlen und Gleitkommazahlen; es gibt kein int), boolean, bigint, symbol, null und undefined, dazu Arrays (number[]), Tupel ([string, number]), Objekttypen, any, unknown, never und void. Verwende die kleingeschriebenen Namen: String und Number sind die Typen der Wrapper-Objekte.

4. Was ist der Unterschied zwischen any und unknown?

Beide akzeptieren jeden Wert. any schaltet zusätzlich die Prüfung ab, sodass jede Operation kompiliert. unknown erlaubt nichts, bis du es einengst, und ist damit der sichere Typ für Werte, die du noch nicht geprüft hast.

let a: any = "hello";
a.toFixed; // allowed: any turns checking off

let u: unknown = "hello";
// @ts-expect-error 'u' is of type 'unknown'.
u.toUpperCase();

if (typeof u === "string") {
  console.log(u.toUpperCase()); // HELLO: narrowed to string
}

5. Was ist Typinferenz?

Der Compiler ermittelt Typen, die du nicht geschrieben hast: let count = 0 ist eine number, const mode = "dark" hat den Literaltyp "dark", und der Rückgabetyp einer Funktion ergibt sich aus ihren return-Anweisungen. Die übliche Regel: Funktionsparameter und öffentliche Rückgabetypen annotieren, lokale Variablen der Inferenz überlassen.

6. Was ist der Unterschied zwischen interface und type?

Beide beschreiben Objektformen, und eine Klasse kann beide mit implements umsetzen. Ein interface kann erneut geöffnet und zusammengeführt werden (Declaration Merging) und mit extends andere Interfaces erweitern. Ein Typalias type kann alles benennen: Unions, Tupel, primitive Typen, Mapped und Conditional Types.

interface User { name: string }
interface User { age: number }       // merged: User has name and age

type Id = string | number;           // only a type alias can be a union
type Pair = [string, number];        // or a tuple
type Admin = User & { role: "admin" };

Eine verbreitete Konvention ist interface für Objektformen und type für alles andere. Der vollständige Vergleich steht auf der Seite interface vs type.

7. Was sind Union- und Intersection-Typen?

Eine Union A | B ist ein Wert, der einer der Typen ist; du kannst nur Member verwenden, die alle gemeinsam haben, bis du ihn einengst. Eine Intersection A & B ist ein Wert, der beides zugleich ist, mit allen Membern beider Typen.

type Id = string | number;                 // either
type Timestamped = { createdAt: Date };
type Post = { title: string } & Timestamped; // both: title and createdAt

8. Was ist der Unterschied zwischen void und never?

void ist der Rückgabetyp einer Funktion, die normal endet, aber keinen brauchbaren Wert liefert. never ist der Typ von etwas, das nicht passieren kann: eine Funktion, die immer wirft oder endlos läuft, oder eine Union, aus der jeder Fall entfernt wurde. never ist jedem Typ zuweisbar, und kein Wert ist never zuweisbar.

function log(msg: string): void { console.log(msg); }
function fail(msg: string): never { throw new Error(msg); }
type Impossible = string & number; // never

Fragen für Fortgeschrittene

9. Was ist Type Narrowing?

Narrowing heißt, dass der Compiler deinen Prüfungen folgt und einen Typ in jedem Zweig verfeinert. Er versteht typeof, instanceof, in, Gleichheitsprüfungen, Truthiness und selbst definierte Type Guards.

class ApiError extends Error {
  constructor(public status: number) {
    super(`HTTP ${status}`);
  }
}

type Input = string | number | { id: number } | ApiError;

function describe(x: Input): string {
  if (typeof x === "string") return `string of length ${x.length}`;
  if (typeof x === "number") return `number ${x.toFixed(1)}`;
  if (x instanceof ApiError) return `error with status ${x.status}`;
  return `object with id ${x.id}`; // only { id: number } is left
}

console.log(describe("hi"));             // string of length 2
console.log(describe(3));                // number 3.0
console.log(describe(new ApiError(404))); // error with status 404
console.log(describe({ id: 7 }));        // object with id 7

10. Was ist ein selbst definierter Type Guard?

Eine Funktion mit dem Rückgabetyp value is T. Gibt sie true zurück, wird die Variable des Aufrufers auf T eingeengt. Der Compiler vertraut der Funktion, ihr Rumpf muss den Wert also wirklich prüfen.

interface Cat { meow(): void }

function isCat(value: unknown): value is Cat {
    return (
        typeof value === "object" &&
        value !== null &&
        "meow" in value &&
        typeof value.meow === "function"
    );
}

Eine Assertion-Funktion, function assertCat(v: unknown): asserts v is Cat, engt ein, indem sie wirft, statt false zurückzugeben.

11. Was sind Generics?

Typparameter, mit denen eine Funktion, Klasse oder ein Typ mit vielen Typen arbeitet und dabei die Verbindung zwischen Eingabe und Ausgabe behält. T wird aus den Argumenten abgeleitet, und extends schränkt ein, was es sein darf.

function first<T>(items: T[]): T | undefined {
  return items[0];
}

const n = first([10, 20]);   // T is number, n is number | undefined
const s = first(["a", "b"]); // T is string

function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
  return items.map((item) => item[key]);
}

const users = [{ name: "Ada", age: 36 }, { name: "Lin", age: 29 }];
console.log(n, s, pluck(users, "name"), pluck(users, "age")); // 10 a [ 'Ada', 'Lin' ] [ 36, 29 ]

pluck(users, "email") wäre ein Compilerfehler, weil "email" kein keyof des User-Typs ist.

12. Was bewirken keyof und typeof in einem Typ?

keyof T ist die Union der Eigenschaftsnamen von T. An einer Typposition liefert typeof x den Typ einer Variablen. Zusammen macht keyof typeof obj die Schlüssel eines Objekts zu einer Union.

const colors = { red: "#f00", green: "#0f0" };
type Colors = typeof colors;        // { red: string; green: string }
type ColorName = keyof typeof colors; // "red" | "green"

13. Was sind Utility Types? Nenne einige.

Eingebaute generische Typen, die andere Typen umwandeln. Die am häufigsten abgefragten:

Die vollständige Liste steht auf der Seite zu Utility Types.

14. Was ist eine Discriminated Union?

Eine Union aus Objekttypen, die eine gemeinsame Literal-Eigenschaft als „Tag“ haben. Die Prüfung des Tags engt den Wert auf einen Member ein, und eine never-Prüfung im Zweig default lässt den Compiler jeden vergessenen Fall melden.

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rect"; width: number; height: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "rect":
      return shape.width * shape.height;
    default: {
      const unreachable: never = shape;
      return unreachable;
    }
  }
}

console.log(area({ kind: "rect", width: 3, height: 4 }));    // 12
console.log(area({ kind: "circle", radius: 1 }).toFixed(2)); // 3.14

15. Was ist der Unterschied zwischen as und satisfies?

value as T ist eine Typ-Assertion: Sie sagt dem Compiler, er solle den Wert als T behandeln, und überspringt die meisten Prüfungen. value satisfies T prüft den Wert gegen T, behält aber den eigenen, genaueren Typ des Werts.

type Theme = { primary: string; secondary: string };

const a = { primary: "#07f" } as Theme;        // compiles: the missing key is not reported
const b = { primary: "#07f" } satisfies Theme; // error TS2741: Property 'secondary' is missing
const c = {} as { name: string };              // compiles; c.name is undefined at run time

Ist das Objekt vollständig, behält satisfies auch seinen eigenen abgeleiteten Typ: Gegen Record<string, string> geprüft, weiß die Variable weiterhin genau, welche Schlüssel sie hat, während eine Annotation sie auf beliebige String-Schlüssel erweitern würde.

16. Was macht der Operator ! hinter einer Variablen?

Das ist die Non-Null-Assertion: el! entfernt null und undefined aus dem Typ. Sie erzeugt keine Prüfung; ist der Wert tatsächlich null, stürzt das Programm dort ab, wo er verwendet wird. Bevorzuge ?., ?? oder ein ausdrückliches if.

17. Was ist der Unterschied zwischen private und #private?

private wird nur vom Compiler durchgesetzt; in der JavaScript-Ausgabe ist die Eigenschaft eine gewöhnliche Eigenschaft. #field ist ein privates Feld von JavaScript, das die Laufzeit durchsetzt.

class Account {
  private pin = "1234"; // TypeScript-only privacy
  #balance = 100;       // JavaScript private field

  get balance() {
    return this.#balance;
  }
}

const acc = new Account();
// acc.pin is error TS2341; bracket access is an allowed escape hatch,
// and at run time pin is an ordinary property:
console.log(acc["pin"]);       // 1234
console.log(Object.keys(acc)); // [ 'pin' ]
console.log(acc.balance);      // 100

protected funktioniert wie private, erlaubt aber auch den Zugriff aus Unterklassen, und readonly verbietet die Neuzuweisung nach der Konstruktion.

18. Was ist der Unterschied zwischen einer abstrakten Klasse und einem Interface?

Ein Interface ist nur ein Typ: Es beschreibt eine Form und verschwindet aus der Ausgabe. Eine abstrakte Klasse ist eine echte Klasse, die nicht instanziiert werden kann; sie kann implementierte Methoden, Felder und Konstruktoren neben abstract-Membern enthalten, die Unterklassen umsetzen müssen. Eine Klasse kann viele Interfaces implementieren, aber nur eine Klasse erweitern.

abstract class Repository<T> {
    protected items: T[] = [];
    abstract validate(item: T): boolean; // subclasses must implement
    add(item: T): void {                 // shared implementation
        if (this.validate(item)) this.items.push(item);
    }
}

19. Was ist Funktionsüberladung in TypeScript?

Mehrere Aufrufsignaturen, gefolgt von einer Implementierung, deren Signatur mit allen kompatibel ist. Aufrufer sehen nur die Überladungen, sodass jeder Aufruf einen genauen Rückgabetyp bekommt.

function parse(value: string): number;
function parse(value: string[]): number[];
function parse(value: string | string[]): number | number[] {
    return Array.isArray(value) ? value.map(Number) : Number(value);
}

const one = parse("4");          // number
const many = parse(["1", "2"]);  // number[]

Hängt der Rückgabetyp nicht vom Argumenttyp ab, ist eine einzige Signatur mit einem Union-Parameter einfacher.

Fragen für Profis

20. Was ist strukturelle Typisierung?

TypeScript vergleicht Typen nach ihrer Form, nicht nach ihrem Namen. Jeder Wert mit den geforderten Eigenschaften wird akzeptiert, auch wenn er nie mit diesem Typ deklariert wurde.

interface Point {
  x: number;
  y: number;
}

function show(p: Point): string {
  return `(${p.x}, ${p.y})`;
}

const pixel = { x: 3, y: 4, color: "red" }; // never declared as a Point
console.log(show(pixel)); // (3, 4): it has the right shape, so it is a Point

class Vector {
  constructor(public x: number, public y: number) {}
}
console.log(show(new Vector(1, 2))); // (1, 2)

Das zusätzliche color ist hier in Ordnung, weil pixel eine Variable ist. Das Objektliteral direkt zu übergeben, show({ x: 3, y: 4, color: "red" }), ist ein Excess Property Error, eine Prüfung, die nur für frische Literale gilt. Wenn sich zwei Typen gleicher Form nicht vermischen dürfen (eine UserId und eine OrderId, die beide Strings sind), nimm einen Branded Type: type UserId = string & { readonly __brand: "UserId" }.

21. Wie würdest du Readonly und Partial selbst umsetzen?

Mit Mapped Types: Iteriere über keyof T und füge jeder Eigenschaft einen Modifikator hinzu.

type MyReadonly<T> = { readonly [K in keyof T]: T[K] };
type MyPartial<T> = { [K in keyof T]?: T[K] };
type Mutable<T> = { -readonly [K in keyof T]: T[K] }; // "-" removes a modifier

type User = { name: string; age: number };
type Draft = MyPartial<User>; // { name?: string; age?: number }

22. Was sind Conditional Types und infer?

T extends U ? X : Y wählt einen Typ anhand einer Bedingung. In der Bedingung deklariert infer eine Typvariable, die einen Teil des passenden Typs erfasst. Conditional Types verteilen sich über Unions.

type MyReturnType<F> = F extends (...args: any[]) => infer R ? R : never;
type ElementOf<T> = T extends (infer E)[] ? E : T;

type A = MyReturnType<() => Promise<number>>; // Promise<number>
type B = ElementOf<string[]>;                 // string
type C = ElementOf<number | boolean[]>;       // number | boolean (distributed)

Weitere Muster stehen auf der Seite zu Conditional Types.

23. Was ist eine .d.ts-Datei, und was macht declare?

Eine Deklarationsdatei enthält nur Typen für Code, der woanders existiert, etwa eine JavaScript-Bibliothek oder Browser-APIs. declare sagt, dass ein Wert existiert, ohne ihn zu erzeugen: declare const VERSION: string; wird zu nichts kompiliert. Bibliothekstypen kommen mit dem Paket oder aus @types/{name}-Paketen, und tsc erzeugt mit declaration: true .d.ts-Dateien für deinen eigenen Code.

24. Was macht strict, und welche tsconfig-Optionen sind am wichtigsten?

"strict": true schaltet noImplicitAny, strictNullChecks, strictFunctionTypes, strictBindCallApply, strictPropertyInitialization, noImplicitThis, useUnknownInCatchVariables und strictBuiltinIteratorReturn ein. In TypeScript 7 ist es standardmäßig aktiv. Die anderen Optionen, nach denen gefragt wird:

25. Was ist TypeScript 7?

Der TypeScript-Compiler, in Go als natives Programm neu geschrieben und als Version 7 des npm-Pakets typescript veröffentlicht. Der Befehl ist weiterhin tsc und die Sprache dieselbe, aber er ist viel schneller als der JavaScript-basierte Compiler 6.x: Das TypeScript-Team berichtet bei typischen vollständigen Builds von 8 bis 12-facher Beschleunigung, durch nativen Code und Multithreading mit gemeinsamem Speicher. Außerdem setzt er Entfernungen durch, die 6.0 als veraltet markiert hatte; zum Beispiel sind baseUrl, outFile, moduleResolution: "node10", module: "amd" und alwaysStrict: false jetzt Fehler (TS5102, TS5108), die dich auffordern, sie zu entfernen.