Antwort.

Geschichte der Frage

TypeScript wurde mit dem Fokus auf sichere Entwicklung ohne übermäßige explizite Typen erstellt: Die meisten Typen von Variablen, Parametern und Rückgabewerten kann der Compiler automatisch ableiten. Das System der Typableitung (type inference) ermöglicht es, Code fast wie in JavaScript zu schreiben, aber mit strenger Typisierung, was die Entwicklung erheblich beschleunigt und die Anzahl der Fehler verringert.

Problem

Die Typableitung garantiert nicht immer, dass der Typ abgeleitet wird, den der Entwickler erwartet. Es gibt Situationen, in denen der Typ zu allgemein (any oder unknown) wird oder umgekehrt - zu strikt. Dies führt entweder zu überflüssigen Einschränkungen oder zu einem Mangel an Typprüfung, was in beiden Fällen unsicher ist.

Lösung

TypeScript leitet den Typ automatisch basierend auf der Zuweisung oder dem Rückgabewert einer Funktion ab, wenn der Typ nicht explizit angegeben ist. Man kann die Ableitung steuern, indem man den Typ explizit angibt, Typbehauptungen, Generika und spezielle Hilfsmittel (ReturnType, Parameters usw.) verwendet. Die Arbeit mit komplexen Strukturen erfordert besondere Kontrolle: Wenn der Typ komplex oder nicht offensichtlich ist, ist es besser, ihn explizit anzugeben.

Beispielcode:

let a = 5; // number (wird automatisch abgeleitet)

function sum(x = 4, y = 3) { // x: number, y: number
  return x + y; // return: number
}

// Fehler bei der Typableitungunction getData(flag) {
  if (flag) return 123;
  // kein return im anderen Zweig — return type: number | undefined
}

// Besser explizit:
function getData(flag: boolean): number | undefined {
  if (flag) return 123;
}

Wesentliche Merkmale:

TypeScript leitet die Typen von Variablen basierend auf der Initialisierung und dem Wert ab.
Für Funktionen und Objekte können die Typen ohne explizite Angabe zu allgemein werden.
Für Generika und komplexe Strukturen sollte man den Typ immer explizit angeben.

Trickfragen.

True/False: Typableitung gibt immer den Typ zurück, den der Entwickler erwartet.

False. Manchmal ist der Typ allgemeiner oder spezifischer, insbesondere für Arrays/Objekte/Union-Rückgabewerte (number | undefined — häufige Überraschung).

Wenn man den Typ in einem Objekt nicht angibt, behält TypeScript immer die genaue Struktur.

Nein, ohne as const wird die Struktur "erweitert" (widened), mit as const wird sie readonly mit literalen Typen.

const obj = { kind: "duck" };
// obj: { kind: string }
const obj2 = { kind: "duck" } as const;
// obj2: { readonly kind: "duck" }

Wenn man den Typ für ein Array nicht angibt, kennt TS immer dessen Zusammensetzung.

Nein, standardmäßig macht TypeScript das Array maximal "breit" — zum Beispiel wird let arr = [1, 'a'] zu (string | number)[], nicht zu einem Tuple.

Typische Fehler und Anti-Patterns

Sich auf die Typableitung für Funktionsparameter (insbesondere API) zu verlassen — Typen können sich bei Änderungen ändern.
Rückgabetypen von Funktionen nicht anzugeben — schwer zu warten.
as const oder explizite Typen für konstante Objekte nicht zu verwenden.

Beispiel aus dem Leben

Negativer Fall

Der Backend gibt ein Antwortobjekt { data: [] } zurück, der Typ ist nicht explizit angegeben, TypeScript leitet den Typ data: any[]. Irgendwann wird data ein Array von Strings — der Fehler tritt erst in der Produktion auf.

Vorteile:

Man muss bei einfachen Fällen die Typen nicht manuell angeben.

Nachteile:

Unklare Fehler bei komplexen Strukturen.
Automatische Ableitung kann ein Problem "schlucken".

Positiver Fall

Im Projekt ist es üblich, den Typ der Rückgabewerte von Funktionen und komplexen Strukturen immer explizit anzugeben und as const für Konstanten zu verwenden. Jede Änderung der Struktur wird vom Compiler überprüft.