TypeScript Academy · Lektion

Boolesche Literale und Literal-Inferenz

Verstehen Sie, wie TypeScript die Inferenz von Literalen erweitert oder einschränkt.

Boolesche Literale und Literal-Inferenz ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Boolesche Literaltypen

Der Typ boolean ist eigentlich die Union true | false. Beide sind boolesche Literaltypen: Typen, die jeweils nur einen bestimmten booleschen Wert zulassen.

let yes: true = true;
let no: false = false;
console.log(yes, no);
// yes = false; // Error: false not assignable to true

Boolesche Literale in Unions

Boolesche Literale sind besonders nützlich in Kombination mit anderen Literalen, um diskriminierte Ergebnisse zu modellieren, etwa ein Erfolgskennzeichen zusammen mit der Form einer Nutzlast.

type Result =
  | { ok: true; value: number }
  | { ok: false; error: string };

const r: Result = { ok: true, value: 42 };
console.log(r);

Typ-Erweiterung

Wenn Sie eine Variable initialisieren, entscheidet TypeScript, welchen Typ es ableiten soll. Manchmal behält es das exakte Literal bei, manchmal erweitert es den Typ zum allgemeinen Typ. Das Verständnis dieses Verhaltens ist entscheidend für vorhersehbare Typen.

const exact = 'hello'; // type: 'hello' (literal)
let broad = 'hello';   // type: string (widened)
console.log(exact, broad);

let wird zum allgemeinen Typ erweitert

Da einer let-Variablen ein neuer Wert zugewiesen werden kann, leitet TypeScript den allgemeinen Typ ab, damit zukünftige Zuweisungen möglich sind. Eine let-Zeichenkette beginnt mit dem Typ string, nicht mit dem Literaltyp.

let mood = 'happy'; // inferred as string
mood = 'sad';       // allowed
mood = 'tired';     // allowed
console.log(mood);

const behält das Literal bei

Eine const-Variable kann niemals neu zugewiesen werden, daher leitet TypeScript den spezifischsten Typ ab — das Literal. Deshalb hat const greeting = 'hi' den Typ 'hi' und nicht string.

const greeting = 'hi'; // type: 'hi'

type Greeting = typeof greeting; // 'hi'
const other: Greeting = 'hi';
console.log(other);

Erweiterung bei Zahlen und booleschen Werten

Dieselbe Regel gilt für Zahlen und boolesche Werte. const behält 42 oder true als Literal bei; let wird zu number oder boolean erweitert.

const n = 42;   // type: 42
const b = true; // type: true
let m = 42;     // type: number
let c = true;   // type: boolean
console.log(n, b, m, c);

Warum Typ-Erweiterung existiert

Die Typ-Erweiterung hält alltäglichen Code komfortabel. Wenn jedes let count = 0 den Literaltyp 0 hätte, könnten Sie den Wert nicht erhöhen. Durch die Erweiterung verhalten sich Variablen, denen neue Werte zugewiesen werden können, auf natürliche Weise.

let count = 0; // widened to number
count = count + 1;
count = 10;
console.log('Count:', count);

Ein Literal per Annotation erzwingen

Manchmal soll ein let ein Literaltyp bleiben. Fügen Sie eine explizite Literaltyp-Annotation hinzu. Dann hält TypeScript den Typ eng, erlaubt aber weiterhin Neuzuweisungen innerhalb dieser Union.

let status: 'on' | 'off' = 'on';
status = 'off'; // allowed
console.log(status);
// status = 'paused'; // Error

Typ-Erweiterung in Objekteigenschaften

Auch Eigenschaften von Objektliteralen werden standardmäßig erweitert. Selbst in einem const-Objekt erhalten veränderliche Eigenschaften den allgemeinen Typ, weil die Eigenschaft selbst neu zugewiesen werden kann.

const config = { mode: 'dark' };
// config.mode has type string, not 'dark'
config.mode = 'light';
console.log(config.mode);

Literal-Inferenz bei Funktionen

Auch Rückgabewerte von Funktionen werden abgeleitet. Eine Funktion, die einen const-Literalwert zurückgibt, erweitert ihren Rückgabetyp dennoch zum allgemeinen Typ, sofern Sie ihn nicht annotieren oder Literaltypen in der Signatur verwenden.

function getMode(): 'dark' | 'light' {
  return 'dark';
}

const m = getMode(); // type: 'dark' | 'light'
console.log(m);

Literaltyp oder allgemeiner Typ

Als Faustregel gilt: Verwenden Sie const oder explizite Literaltyp-Annotationen, wenn Sie exakte Werte benötigen, etwa für Konfigurationsschlüssel oder Diskriminatoren. Lassen Sie bei gewöhnlichen veränderlichen Variablen das Widening zu. Wenn Sie wissen, welcher Fall eintritt, vermeiden Sie überraschende Zuweisbarkeitsfehler.

const KEY = 'apiUrl';     // literal 'apiUrl'
let retries = 3;          // number
let level: 'low' | 'high' = 'low'; // pinned literal
console.log(KEY, retries, level);

Kurzer Test

Testen Sie Ihr Verständnis von Widening und Literal-Inferenz.

Zusammenfassung: Literal-Inferenz

Die wichtigsten Erkenntnisse:

true und false sind Literaltypen; boolean entspricht true | false.
let wird auf den allgemeinen Typ erweitert (string, number, boolean).
const behält den exakten Literaltyp bei.
Annotieren Sie mit einem Literaltyp, um ein let auf eine enge Union festzulegen.

Als Nächstes machen wir Unveränderlichkeit mit as const explizit.

const literal = 'fixed'; // 'fixed'
let widened = 'fixed';   // string
let pinned: 'a' | 'b' = 'a';
console.log(literal, widened, pinned);

Häufig gestellte Fragen

Ist die Lektion „Boolesche Literale und Literal-Inferenz“ kostenlos?

Ja — der vollständige Text von „Boolesche Literale und Literal-Inferenz“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Boolesche Literale und Literal-Inferenz“?

Verstehen Sie, wie TypeScript die Inferenz von Literalen erweitert oder einschränkt. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Boolesche Literale und Literal-Inferenz“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu TypeScript Academy