Typsystem und Compiler

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.

SpracheSchreibweiseReichweite
TypeScriptlet, const ohne TypangabeVariablen, Rückgaben, Callbacks, Generics
C#var (seit C# 3.0)Lokale Variablen
Javavar (seit Java 10)Lokale Variablen
C++auto (seit C++11)Variablen, seit C++14 auch Rückgaben
Rustlet ohne TypangabeFunktionsrumpf, Signaturen sind Pflicht
HaskellTypsignatur optionalGanzes 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
Nicht verwechseln

Typinferenz und was oft damit gleichgesetzt wird

Typinferenz gegen Dynamische Typisierung

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.

Typinferenz gegen Typannotation

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.

Typinferenz gegen Type Assertion mit as

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.

Typinferenz gegen Strukturelle Typisierung

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
In der Praxis

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.

Häufige Fragen

Verlangsamt Typinferenz den Build?
Spürbar wird das erst bei tief verschachtelten Generics und sehr großen Union-Typen, wo der Compiler viele Kombinationen durchrechnet. Wenn der Typcheck eines Projekts zäh wird, hilft es meist, genau an diesen Stellen die Rückgabetypen zu annotieren, damit TypeScript sie nicht jedes Mal neu bestimmen muss.
Was ist der Unterschied zwischen any und unknown bei abgeleiteten Typen?
any schaltet die Prüfung ab, unknown behält sie bei und zwingt dich, den Typ vor der Verwendung einzugrenzen. Für Daten von außen ist unknown deshalb die bessere Wahl, auch wenn du dafür eine Prüfung schreiben musst.
Hat Python Typinferenz?
Python selbst prüft keine Typen vor dem Start. Werkzeuge wie mypy oder Pyright leiten aber Typen aus Zuweisungen und Rückgaben ab und prüfen sie gegen die Type Hints, ganz ähnlich wie der TypeScript-Compiler.
Was ist der Hindley-Milner-Algorithmus?
Ein Verfahren zur Typinferenz, mit dem Sprachen wie Haskell oder OCaml die Typen eines ganzen Programms ohne eine einzige Annotation bestimmen können, auch für Funktionen. Es sucht für jeden Ausdruck den allgemeinsten passenden Typ. Mainstream-Sprachen wie TypeScript oder C# arbeiten mit einfacheren, lokalen Verfahren.

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.

Persönlich für dich da

Deine Ansprechpartner

Du willst das Thema nicht nur nachschlagen, sondern anwenden können? Wir beraten dich persönlich und kostenlos.

Yves Hoppe

Yves Hoppe

Weiterbildung & Beratung

Ordnet mit dir ein, welcher Kurs zu deinem Vorwissen passt.

Norbert Jansen

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.