Sie haben in Kapitel 4 JEDE Variable explizit typisiert (let titel: string = ...) – das ist in den meisten Fällen GAR NICHT nötig. TypeScript erkennt Typen oft von selbst. Dieses Kapitel zeigt, WANN Sie sich auf diese "Type Inference" verlassen können, und WANN explizite Annotationen tatsächlich nötig sind.

Was ist Type Inference?

"Inference" (Ableitung) bedeutet: TypeScript SCHAUT sich den zugewiesenen Wert an und LEITET den Typ automatisch daraus ab – Sie müssen ihn nicht selbst hinschreiben:

let titel = 'Der Herr der Ringe';   // TypeScript leitet ab: string
let seitenzahl = 1216;              // TypeScript leitet ab: number
let istVerfuegbar = true;           // TypeScript leitet ab: boolean

titel = 42; // Fehler - trotz FEHLENDER expliziter Annotation bleibt titel als string erkannt

WICHTIG: die Typprüfung funktioniert bei INFERIERTEN Typen GENAUSO streng wie bei expliziten – TypeScript "merkt sich" den abgeleiteten Typ dauerhaft, es ist NICHT so, dass fehlende Annotation automatisch any bedeutet (das wäre nur ohne strict/noImplicitAny der Fall, siehe Kapitel 3).

Wann Inference an ihre Grenzen stößt

let bewertung;           // Kein Anfangswert - TypeScript kann NICHTS ableiten, Typ wird 'any'
bewertung = 4.5;
bewertung = 'sehr gut'; // KEIN Fehler - 'any' erlaubt alles!

let genres = [];         // Leeres Array - Typ wird implizit 'any[]'
genres.push('Fantasy');  // funktioniert, aber ohne echte Typsicherheit

Die Faustregel: wann explizit annotieren?

• NICHT nötig bei Variablen mit sofortigem Anfangswert – let seitenzahl = 1216; ist genauso typsicher wie mit expliziter Annotation, aber kürzer zu lesen.
• PFLICHT bei Variablen ohne Anfangswert, die erst SPÄTER befüllt werden – let ergebnis: number;
• PFLICHT bei Funktionsparametern – TypeScript kann NIEMALS aus dem Aufrufkontext ableiten, welchen Typ ein Parameter haben soll (ausführlich in Kapitel 6).
• EMPFOHLEN bei Funktions-Rückgabetypen – technisch oft ableitbar, aber eine explizite Angabe dient als "Vertrag", der SOFORT einen Fehler zeigt, wenn sich die Funktion später versehentlich anders verhält (mehr dazu ebenfalls Kapitel 6).

Type Inference bei Objekten

const buch = {
  titel: 'Der Herr der Ringe',
  seitenzahl: 1216,
  istVerfuegbar: true,
};
// TypeScript leitet ab: { titel: string; seitenzahl: number; istVerfuegbar: boolean }

buch.seitenzahl = '1216'; // Fehler - seitenzahl bleibt als number erkannt
buch.autor = 'Tolkien';   // Fehler - 'autor' existiert nicht auf dem abgeleiteten Typ

TypeScript leitet bei Objekt-Literalen die GESAMTE Form ab – jede Eigenschaft bekommt ihren eigenen, präzisen Typ, und der abgeleitete Objekttyp ist "geschlossen": nachträgliches Hinzufügen einer NICHT ursprünglich vorhandenen Eigenschaft wird als Fehler erkannt. Ein wichtiger Vorgeschmack auf Kapitel 7 (Interfaces), wo wir Objektformen EXPLIZIT benennen und wiederverwenden.

Bonus: const erzeugt PRÄZISERE Typen als let

let a = 'Fantasy';   // Typ: string (könnte sich später ändern)
const b = 'Fantasy'; // Typ: 'Fantasy' (ein "Literal Type" - kann sich NIE ändern, const!)

Weil const-Variablen NIE neu zugewiesen werden können, leitet TypeScript den PRÄZISESTEN möglichen Typ ab – nicht "irgendein string", sondern GENAU diesen einen Wert. Dieses Konzept ("Literal Types") wird in Kapitel 10 vertieft, wo es für Enums und eingeschränkte Wertemengen wichtig wird.