TypeScript Academy · Lektion

String- und numerische Literaltypen

Beschränken Sie Werte mithilfe von Literaltypen auf exakt festgelegte Strings und Zahlen.

String- und numerische Literaltypen ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Was ist ein Literaltyp?

Die meisten Typen beschreiben eine Menge von Werten. string steht für eine beliebige Zeichenkette, number für eine beliebige Zahl. Ein Literaltyp schränkt dies auf genau einen Wert ein.

Der Typ 'north' erlaubt nur die Zeichenkette 'north' — nichts anderes. Mit Literaltypen können Sie präzise, endliche Mengen zulässiger Werte direkt im Typsystem modellieren.

let dir: 'north' = 'north';
console.log(dir);
// dir = 'south'; // Error: not assignable to type 'north'

String-Literal-Unions

Ein einzelnes Literal ist allein nicht besonders nützlich. Kombinieren Sie mehrere mit |, um eine Vereinigung von Literalen zu bilden. Dies ist die idiomatische Art, eine feste Menge von Optionen zu modellieren.

Direction kann immer nur eine von vier exakt festgelegten Zeichenketten sein.

type Direction = 'north' | 'south' | 'east' | 'west';

let heading: Direction = 'east';
console.log('Heading:', heading);

heading = 'west';
console.log('Now:', heading);

Ungültige Werte zurückweisen

Die Stärke von Literal-Unions besteht darin, dass der Compiler alles außerhalb der zulässigen Menge zurückweist. Tippfehler und ungültige Optionen werden zu Kompilierzeitfehlern statt zu Fehlern zur Laufzeit.

type Direction = 'north' | 'south' | 'east' | 'west';

let heading: Direction = 'north';
console.log(heading);
// heading = 'up'; // Error: '"up"' is not assignable to 'Direction'

Literale als Funktionsparameter

Verwenden Sie Literal-Unions für Funktionsparameter, die nur bestimmte Werte akzeptieren. Die aufrufende Stelle erhält eine Autovervollständigung und wird daran gehindert, ungültige Werte zu übergeben.

type Direction = 'north' | 'south' | 'east' | 'west';

function move(dir: Direction): string {
  return 'Moving ' + dir;
}

console.log(move('south'));
// console.log(move('left')); // Error

Numerische Literaltypen

Literaltypen sind nicht auf Zeichenketten beschränkt. Sie können auch exakte Zahlen verwenden. Ein klassisches Beispiel ist ein sechsseitiger Würfel, dessen Augenwert eine Zahl von 1 bis 6 sein muss.

type Dice = 1 | 2 | 3 | 4 | 5 | 6;

function roll(): Dice {
  return (Math.floor(Math.random() * 6) + 1) as Dice;
}

console.log('Rolled:', roll());

Numerische Literale in Parametern

Numerische Literal-Unions beschränken Eingaben auf eine exakt festgelegte Menge von Zahlen — ideal für Dinge wie Qualitätsstufen, HTTP-ähnliche Statuscodes oder Rastergrößen.

type Quality = 1 | 2 | 3;

function setQuality(level: Quality): void {
  console.log('Quality set to', level);
}

setQuality(2);
// setQuality(5); // Error: 5 is not 1 | 2 | 3

String- und numerische Literale kombinieren

Eine Union kann verschiedene Literalarten kombinieren. Das ist praktisch für APIs, die entweder eine benannte Voreinstellung oder einen Rohwert akzeptieren.

type Size = 'small' | 'large' | 0 | 100;

function resize(s: Size): void {
  console.log('Resizing to', s);
}

resize('small');
resize(100);

Boolesche Literaltypen

Auch boolesche Werte haben Literaltypen: true und false sind sowohl Typen als auch Werte. Der vollständige Typ boolean ist eigentlich nur true | false.

type AlwaysOn = true;

let enabled: AlwaysOn = true;
console.log('Enabled:', enabled);
// enabled = false; // Error: false not assignable to true

Literale verbessern die Dokumentation

Eine Literal-Union dient zugleich als Dokumentation. Wer type Status = 'idle' | 'loading' | 'done' liest, kennt sofort jeden möglichen Zustand — kein Rätselraten und keine über den Code verstreuten magischen Zeichenketten.

type Status = 'idle' | 'loading' | 'done';

function render(s: Status): string {
  return 'State is: ' + s;
}

console.log(render('loading'));

Literale mit anderen Typen kombinieren

Sie können Literaltypen in einer Union mit allgemeineren Typen kombinieren. Ein häufiges Muster ist 'auto' | number und bedeutet entweder das spezielle Schlüsselwort 'auto' oder eine beliebige Zahl.

type Width = 'auto' | number;

function setWidth(w: Width): void {
  console.log('Width:', w);
}

setWidth('auto');
setWidth(320);

Literale als benannte Konstanten

Literaltypen lassen sich hervorragend mit benannten Konstanten kombinieren. Definieren Sie den Typ einmal, verwenden Sie ihn überall wieder und führen Sie Refactorings sicher durch. Der Compiler hält jede Verwendung konsistent.

type Theme = 'light' | 'dark';

const DEFAULT_THEME: Theme = 'dark';

function applyTheme(t: Theme): void {
  console.log('Applying', t, 'theme');
}

applyTheme(DEFAULT_THEME);

Schnelltest

Testen Sie Ihr Verständnis von Literaltypen.

Rückblick: Literaltypen

Sie haben gelernt:

Literaltypen repräsentieren genau einen Wert, zum Beispiel 'north' oder 6.
Durch das Kombinieren von Literalen mit | entsteht eine endliche Union zulässiger Werte.
Sie funktionieren für Zeichenketten, Zahlen und boolesche Werte und können mit allgemeineren Typen wie 'auto' | number kombiniert werden.
Als Funktionsparameter bieten sie eine Autovervollständigung und weisen ungültige Eingaben bereits zur Kompilierzeit zurück.

Als Nächstes untersuchen wir, wie TypeScript zwischen Literaltypen und erweiterten Typen entscheidet.

type Direction = 'north' | 'south' | 'east' | 'west';
type Dice = 1 | 2 | 3 | 4 | 5 | 6;

function describe(d: Direction, n: Dice): string {
  return 'Go ' + d + ' ' + n + ' steps';
}

console.log(describe('north', 3));

Häufig gestellte Fragen

Ist die Lektion „String- und numerische Literaltypen“ kostenlos?

Ja — der vollständige Text von „String- und numerische Literaltypen“ 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 „String- und numerische Literaltypen“?

Beschränken Sie Werte mithilfe von Literaltypen auf exakt festgelegte Strings und Zahlen. 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 1 von 4.

Wie lange dauert die Lektion „String- und numerische Literaltypen“?

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