Was ist Typinferenz?
Type Inference
Typinferenz ist die Fähigkeit eines Compilers, den Typ eines Ausdrucks aus dem Zusammenhang zu erschließen, statt ihn im Quelltext ausdrücklich genannt zu bekommen. Der Code bleibt statisch typisiert und wird genauso streng geprüft, du schreibst nur weniger Typangaben, etwa in TypeScript, C#, Java, C++ oder Rust.
Du schreibst in TypeScript selten einen Typ hin und bekommst trotzdem schon beim Tippen angezeigt, dass ein Feld fehlt. Dahinter steckt die Ableitung durch den Compiler.
KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt
- Findet sich in
- TypeScript, C#, Java, C++, Rust, Kotlin, Haskell
- Leitet ab aus
- Zuweisung, Rückgabewert und Aufrufkontext
- Grenze
- Daten von außen, etwa aus JSON
- Verwechselt mit
- Dynamischer Typisierung
Woher der Compiler den Typ nimmt
Die einfachste Quelle ist die Zuweisung. Bei let preis = 19.9 steht fest, dass eine Zahl gemeint ist, und jede spätere Zuweisung eines Textes meldet einen Fehler. Dabei macht die Art der Deklaration einen Unterschied: In TypeScript bekommt let name = 'Anna' den Typ string, const name = 'Anna' dagegen den Literaltyp 'Anna', weil sich der Wert nicht mehr ändern kann.
Die zweite Quelle ist der Rumpf einer Funktion, aus dem der Compiler den Rückgabetyp berechnet. Die dritte ist der Kontext der Verwendung. Übergibst du eine Pfeilfunktion an array.map, kennt der Compiler die erwartete Signatur des Callbacks und leitet daraus den Typ des Parameters ab. Genau deshalb musst du bei Callbacks fast nie etwas annotieren.
Bei Generics arbeitet die Ableitung über die Argumente:
function ersteElement<T>(liste: T[]): T | undefined {
return liste[0];
}
const namen = ['Anna', 'Ben']; // abgeleitet: string[]
const erster = ersteElement(namen); // T = string, erster: string | undefined Der Aufruf kommt ohne spitze Klammern aus, weil T aus dem übergebenen Array bestimmt wird. In der IDE siehst du den abgeleiteten Typ, wenn du mit der Maus über den Namen fährst. Das ist der schnellste Weg, um zu prüfen, ob der Compiler dasselbe denkt wie du.
Typinferenz in verschiedenen Sprachen
Wie weit die Ableitung reicht, ist von Sprache zu Sprache verschieden. Die meisten verbreiteten Sprachen leiten lokal ab, also innerhalb einer Funktion, und verlangen an Signaturen ausdrückliche Typen. Funktionale Sprachen wie Haskell oder OCaml gehen weiter und leiten mit dem Hindley-Milner-Verfahren auch Funktionstypen ab.
| Sprache | Schreibweise | Reichweite |
|---|---|---|
| TypeScript | let, const ohne Typangabe | Variablen, Rückgaben, Callbacks, Generics |
| C# | var (seit C# 3.0) | Lokale Variablen |
| Java | var (seit Java 10) | Lokale Variablen |
| C++ | auto (seit C++11) | Variablen, seit C++14 auch Rückgaben |
| Rust | let ohne Typangabe | Funktionsrumpf, Signaturen sind Pflicht |
| Haskell | Typsignatur optional | Ganzes Programm |
In allen Fällen steht der Typ nach dem Übersetzen fest. var in C# oder Java ist deshalb nicht dasselbe wie var im alten JavaScript: Die Variable kann ihren Typ später nicht wechseln.
Wann du trotzdem annotierst
Drei Stellen lohnen die ausdrückliche Angabe. Die erste sind öffentliche Schnittstellen: Wird der Rückgabetyp einer exportierten Funktion nur abgeleitet, ändert sich die Schnittstelle stillschweigend mit, sobald jemand den Rumpf umbaut, und der Fehler taucht erst bei den Aufrufern auf. Eine Annotation meldet ihn dort, wo er entsteht.
Die zweite Stelle sind leere Sammlungen. const eintraege = [] gilt als any[], solange TypeScript den Inhalt nicht aus späteren push-Aufrufen erschließen kann, während const eintraege: Buchung[] = [] von Anfang an festhält, was hineingehört. Die dritte sind Werte von außen. Was aus JSON.parse oder aus einer Netzwerkantwort kommt, kennt der Compiler nicht. Hier legst du selbst fest, womit du rechnest, am besten zusammen mit einer Prüfung zur Laufzeit.
Wo die Ableitung in die Irre führt
Der häufigste Ärger entsteht durch zu breite Ableitung. Ein Objektliteral, das du in einer Variablen zwischenspeicherst, bekommt für ein Feld mit dem Wert 'GET' den Typ string und nicht den Literaltyp 'GET'. Erwartet die aufgerufene Funktion eine Union aus 'GET' und 'POST', schlägt die Übergabe fehl, obwohl der Wert stimmt:
const anfrage = { url: '/api', methode: 'GET' };
// abgeleitet: { url: string; methode: string }
sende(anfrage); // Fehler: string ist nicht 'GET' | 'POST'
const anfrage2 = { url: '/api', methode: 'GET' } as const;
const anfrage3 = { url: '/api', methode: 'GET' } satisfies Anfrage; as const friert alle Werte als Literaltypen ein. Der Operator satisfies, seit TypeScript 4.9 verfügbar, prüft das Objekt gegen einen Typ und behält trotzdem die genaueren abgeleiteten Typen bei.
In die andere Richtung kann die Ableitung Fehler verdecken. Fließt irgendwo any hinein, etwa aus einer Bibliothek ohne Typdefinitionen, wandert dieser Typ durch die ganze Aufrufkette und macht alles Folgende ungeprüft, ohne dass eine Warnung erscheint. Die Compileroption noImplicitAny fängt nur den impliziten Fall ab, ein ausdrücklich deklariertes any aus einer fremden Deklaration bleibt unsichtbar.
KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt
Typinferenz und was oft damit gleichgesetzt wird
In JavaScript oder Python steht der Typ eines Werts erst zur Laufzeit fest und eine Variable kann nacheinander Zahl und Text enthalten. Bei Typinferenz steht der Typ beim Übersetzen fest, er wird nur nicht hingeschrieben. Ein Typfehler fällt deshalb vor dem Start auf, nicht im Betrieb.
Die Annotation schreibt den Typ vor, die Inferenz liest ihn ab. Beide führen zur gleichen Prüfung, aber eine Annotation ist zusätzlich eine Zusicherung: Weicht der Rumpf davon ab, meldet der Compiler den Fehler an der Funktion selbst.
Mit as behauptest du gegenüber dem Compiler einen Typ, ohne dass er geprüft wird. Das ist keine Ableitung, sondern deren Abschaltung an dieser Stelle, und einer der häufigsten Gründe für Laufzeitfehler in typisiertem Code.
TypeScript vergleicht Typen anhand ihres Aufbaus und nicht anhand ihres Namens. Das ist unabhängig von der Inferenz, wird mit ihr aber oft verwechselt, weil beides dazu führt, dass man selten Typnamen hinschreiben muss.
KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt
Im Team entscheidet eine Regel, wo abgeleitet werden darf
Ohne Absprache schreibt eine Hälfte des Teams jeden Typ aus und die andere keinen, und im Review dreht sich die Diskussion um Geschmack. Bewährt hat sich eine einfache Linie: Innerhalb einer Funktion leitet der Compiler ab, an Modulgrenzen, also bei exportierten Funktionen, öffentlichen Klassen und API-Typen, steht der Typ ausdrücklich da. Eine Lint-Regel wie explicit-module-boundary-types aus typescript-eslint setzt das automatisch durch.
Die Grenze nach außen verdient eine eigene Regel. In dem Moment, in dem eine Antwort aus dem Netz oder ein Wert aus einer Datenbank hereinkommt, hat der Compiler keine Grundlage mehr. Ein Schema-Validator wie Zod prüft die Daten zur Laufzeit und liefert gleichzeitig den passenden Typ, sodass ab dort die Inferenz wieder trägt.
Große Projekte haben noch einen technischen Grund, an Exporten zu annotieren. Mit der Option isolatedDeclarations, eingeführt in TypeScript 5.5, verlangt der Compiler ausdrückliche Typen an allen Exporten. Dafür lassen sich die Deklarationsdateien je Datei unabhängig erzeugen, was Builds in Monorepos parallelisierbar macht.
Typinferenz lernen
Wie weit du die Ableitung treiben kannst und wo eine Annotation die Schnittstelle stabil hält, zeigen die TypeScript-Trainings für Entwicklerteams an durchgehenden Beispielprojekten.
Typen fangen nur Formfehler ab, das Verhalten prüfst du weiterhin mit Tests, wie sie die Kurse rund um automatisierte Tests behandeln.
Kurse, die Typinferenz behandeln
Häufige Fragen
Verlangsamt Typinferenz den Build?
Was ist der Unterschied zwischen any und unknown bei abgeleiteten Typen?
Hat Python Typinferenz?
Was ist der Hindley-Milner-Algorithmus?
Passt thematisch dazu
Der nächste Schritt nach der Inferenz ist, Typen per typeof und keyof aus einer einzigen Quelle zu gewinnen, statt dieselbe Struktur an drei Stellen zu pflegen.
Wo die Ableitung an Daten von außen endet, helfen unknown, Typwächter und Schemas statt any, damit die Prüfung nicht still abreißt.
Deine Ansprechpartner
Du willst das Thema nicht nur nachschlagen, sondern anwenden können? Wir beraten dich persönlich und kostenlos.
Yves Hoppe
Weiterbildung & Beratung
Ordnet mit dir ein, welcher Kurs zu deinem Vorwissen passt.
Norbert Jansen
Beratung & Inhouse
Plant Inhouse-Trainings, die an euren eigenen Daten und Abläufen ansetzen.
Typinferenz im Kurs statt im Lexikon
Nachschlagen bringt dich bis zum Verstehen. Anwenden lernst du an echten Aufgaben.