TypeScript Academy · Lektion

const-Assertions mit as const

Machen Sie Objekte und Arrays mit tief unveränderlichen Literaltypen unveränderlich.

const-Assertions mit as const ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Die as-const-Assertion

Eine const assertion, geschrieben als as const, weist TypeScript an, für einen Wert den spezifischsten, auf allen Ebenen readonly gesetzten Typ zu inferieren. Objekteigenschaften werden zu Literalen und unveränderlich, Arrays zu readonly Tupeln.

const point = { x: 10, y: 20 } as const;
// type: { readonly x: 10; readonly y: 20 }
console.log(point.x, point.y);

Ohne as const

Ohne die Assertion werden Objekteigenschaften erweitert. { x: 10 } wird als x: number inferiert und ist veränderlich. Vergleichen Sie dies mit der vorherigen Szene, um zu sehen, was as const verändert.

const a = { x: 10 };       // x: number, mutable
const b = { x: 10 } as const; // x: 10, readonly
a.x = 99; // allowed
console.log(a.x, b.x);

Eigenschaften auf Literale festlegen

as const wandelt jede String-Eigenschaft in ihren Literaltyp um. Das ist für Konfigurationsobjekte besonders wertvoll, deren Schlüssel und Werte exakt erhalten bleiben müssen.

const config = {
  env: 'production',
  retries: 3
} as const;
// env: 'production', retries: 3
console.log(config.env, config.retries);

readonly verhindert Änderungen

Da as const Eigenschaften als readonly festlegt, verhindert der Compiler ihre Neuzuweisung. Der Wert ist auf Typebene unveränderlich und dadurch vor versehentlichen Änderungen geschützt.

const settings = { mode: 'dark' } as const;
console.log(settings.mode);
// settings.mode = 'light'; // Error: readonly property

Const-Assertions bei Arrays

Auf ein Array angewendet, erzeugt as const ein readonly tuple aus Literaltypen. Die Länge ist festgelegt und jedes Element behält seinen exakten Wert.

const colors = ['red', 'green', 'blue'] as const;
// type: readonly ['red', 'green', 'blue']
console.log(colors[0], colors.length);

Keine Änderungen an readonly Arrays

Ein readonly Tupel weist verändernde Methoden wie push oder Zuweisungen über einen Index zurück. Die Daten sind geschützt – genau das, was Sie für feste Nachschlagetabellen benötigen.

const days = ['Mon', 'Tue', 'Wed'] as const;
console.log(days.join(', '));
// days.push('Thu'); // Error: push does not exist on readonly tuple

Eine Union mit typeof arr[number] ableiten

Ein leistungsfähiges Muster: Nehmen Sie ein readonly-Array und leiten Sie mit typeof arr[number] eine Union seiner Elementtypen ab. Sie schreiben die Werte einmal und erhalten nebenbei eine Literal-Union.

const ROLES = ['admin', 'editor', 'viewer'] as const;
type Role = typeof ROLES[number];
// 'admin' | 'editor' | 'viewer'
const r: Role = 'editor';
console.log(r);

Single Source of Truth

So bleiben Ihr Array zur Laufzeit und Ihr Typ synchron. Fügen Sie dem Array einen Wert hinzu, wird die Union automatisch aktualisiert – es müssen keine doppelten Listen gepflegt werden.

const SIZES = ['S', 'M', 'L', 'XL'] as const;
type Size = typeof SIZES[number];

function pick(s: Size): void {
  console.log('Picked', s);
}
pick('M');

Const-Assertions bei Tupeln

Bei Tupeln mit unterschiedlichen Elementtypen bewahrt as const sowohl die exakten Typen als auch die Reihenfolge und erzeugt so ein präzises readonly Tupel.

const pair = [1, 'one'] as const;
// type: readonly [1, 'one']
console.log(pair[0], pair[1]);

Readonly-Verhalten auf allen Ebenen

as const wirkt auf allen Ebenen. Verschachtelte Objekte und Arrays werden ebenfalls bis in die tiefsten Ebenen zu readonly Werten mit Literaltypen.

const data = {
  name: 'app',
  tags: ['a', 'b']
} as const;
// tags is readonly ['a', 'b']
console.log(data.name, data.tags[1]);

Const-Assertions für Enums

Ein const-Objekt plus eine abgeleitete Union ist eine schlanke Alternative zu enum. Sie erhalten Literalwerte zur Laufzeit und einen exakten Typ – ohne zusätzlich erzeugten Code.

const Status = {
  Idle: 'idle',
  Active: 'active'
} as const;
type Status = typeof Status[keyof typeof Status];
const s: Status = Status.Active;
console.log(s);

Kurzer Test

Testen Sie Ihr Verständnis von const-Assertions.

Zusammenfassung: as const

Sie haben gelernt, dass as const:

den spezifischsten, auf allen Ebenen readonly gesetzten Literaltyp inferiert.
Objekteigenschaften in Literaltypen und readonly Felder umwandelt.
Arrays in readonly tuples aus Literalen umwandelt.
das Ableiten von Unions mit typeof arr[number] ermöglicht und dadurch Werte und Typen synchron hält.

Als Nächstes kombinieren wir Literale zu ausdrucksstarken Unions.

const LEVELS = ['low', 'mid', 'high'] as const;
type Level = typeof LEVELS[number];
const chosen: Level = 'mid';
console.log(chosen);

Häufig gestellte Fragen

Ist die Lektion „const-Assertions mit as const“ kostenlos?

Ja — der vollständige Text von „const-Assertions mit as const“ 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 „const-Assertions mit as const“?

Machen Sie Objekte und Arrays mit tief unveränderlichen Literaltypen unveränderlich. 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 3 von 4.

Wie lange dauert die Lektion „const-Assertions mit as const“?

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