TypeScript Academy · Lektion

Assertions und Type Guards

Bevorzugen Sie, wo möglich, Laufzeitprüfungen gegenüber Assertions.

Assertions und Type Guards ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Zwei Wege, den Compiler zu überzeugen

Wenn der Compiler den exakten Typ eines Werts nicht kennt, haben Sie zwei Möglichkeiten: Sie können ihn per Assertion als bestimmten Typ angeben oder ihn mit einem Type Guard zur Laufzeit nachweisen. Beides sieht ähnlich aus, bietet aber ein sehr unterschiedliches Maß an Sicherheit.

function viaAssert(v: unknown): number {
  return (v as number) + 1; // claim
}
function viaGuard(v: unknown): number {
  return typeof v === 'number' ? v + 1 : 0; // prove
}
console.log(viaAssert(5), viaGuard(5), viaGuard('x'));

Assertions überprüfen nicht

Eine Assertion ist ein Versprechen ohne Absicherung. Wenn Sie sich irren, gelangt der Fehler bis zur Laufzeit. Assertions tauschen Sicherheit gegen Bequemlichkeit.

const v: unknown = 'hello';
const n = v as number;
console.log(n.toFixed(2)); // runtime error: toFixed is not a function

Type Guards prüfen zur Laufzeit

Ein Type Guard prüft den Wert tatsächlich. Wenn die Prüfung erfolgreich ist, wissen sowohl Sie als auch der Compiler, dass der Typ korrekt ist – die Typ-Eingrenzung wird durch einen echten Laufzeittest abgesichert.

function toFixed2(v: unknown): string {
  if (typeof v === 'number') return v.toFixed(2);
  return 'N/A';
}
console.log(toFixed2(3.14159), toFixed2('hi'));

Benutzerdefinierte Type-Guard-Funktionen

Kapseln Sie komplexe Prüfungen in einem wiederverwendbaren Guard, der value is T zurückgibt. Die gesamte Codebasis profitiert von einer einzigen, gut getesteten Validierung.

type Email = { address: string };
function isEmail(v: unknown): v is Email {
  return typeof v === 'object' && v !== null &&
    'address' in v && typeof (v as any).address === 'string';
}
console.log(isEmail({ address: 'a@b.com' }), isEmail(null));

Guards kombinieren und wiederverwenden

Da Guards gewöhnliche Funktionen sind, können Sie sie kombinieren, testen und wiederverwenden. Assertions hingegen sind verstreute Behauptungen, die nicht zentral validiert werden können.

function isString(v: unknown): v is string { return typeof v === 'string'; }
function isNonEmpty(v: unknown): v is string {
  return isString(v) && v.length > 0;
}
console.log(isNonEmpty('hi'), isNonEmpty(''));

Assertion-Funktionen mit asserts

TypeScript bietet außerdem Assertion-Funktionen. Ihre Rückgabeannotation verwendet das Schlüsselwort asserts. Wenn die Funktion normal zurückkehrt, grenzt der Compiler das Argument ab diesem Punkt ein. Wenn die Bedingung fehlschlägt, löst die Funktion einen Fehler aus.

function assertNumber(v: unknown): asserts v is number {
  if (typeof v !== 'number') throw new Error('not a number');
}
function use(v: unknown): number {
  assertNumber(v); // after this line, v is number
  return v * 2;
}
console.log(use(21));

asserts vs value is

Ein value is T-Guard gibt einen booleschen Wert zurück, anhand dessen Sie eine Verzweigung vornehmen. Eine Funktion mit asserts value is T löst bei einem Fehler einen Fehler aus und grenzt den Typ für den restlichen Gültigkeitsbereich ein. Beide sind im Gegensatz zu einem einfachen as durch die Laufzeit abgesichert.

function assertDefined<T>(v: T): asserts v is NonNullable<T> {
  if (v === null || v === undefined) throw new Error('missing');
}
const maybe: string | null = 'ok';
assertDefined(maybe);
console.log(maybe.length); // narrowed to string

Generische Assertion-Hilfsfunktionen

Assertion-Funktionen eignen sich hervorragend als wiederverwendbare Vorbedingungen. Eine einzige Hilfsfunktion wie assert(condition) kann Invarianten in Ihrem gesamten Code absichern und bei Verletzungen frühzeitig einen Fehler auslösen.

function assert(cond: unknown, msg: string): asserts cond {
  if (!cond) throw new Error(msg);
}
function half(n: number): number {
  assert(n % 2 === 0, 'must be even');
  return n / 2;
}
console.log(half(8));

Sicherheit im Vergleich

Von sicher nach riskant geordnet: Type Guards und Assertion-Funktionen (zur Laufzeit geprüft) stehen über einfachen as-Assertions (ungeprüft), die wiederum über doppelten Assertions (aktiv irreführend) stehen. Greifen Sie auf das sicherste passende Werkzeug zurück.

// Safe: guard
function safe(v: unknown) {
  return typeof v === 'string' ? v.trim() : '';
}
console.log(safe('  hi  '));

Das richtige Werkzeug auswählen

Verwenden Sie einen Type Guard, wenn Sie anhand des Typs eine Verzweigung vornehmen. Verwenden Sie eine Assertion-Funktion, wenn eine Vorbedingung erfüllt sein muss oder die Ausführung andernfalls beendet werden soll. Verwenden Sie as nur, wenn eine Typ-Eingrenzung nicht möglich ist, etwa bei einer Spezialisierung von DOM-Elementen.

function getInput(v: unknown): asserts v is string {
  if (typeof v !== 'string') throw new Error('expected string');
}
const raw: unknown = 'name';
getInput(raw);
console.log(raw.toUpperCase());

Laufzeitprüfungen sind die bessere Wahl

Das wiederkehrende Thema dieses Kurses lautet: Bevorzugen Sie Laufzeitprüfungen gegenüber Assertions. Guards und Assertion-Funktionen bieten Ihnen sowohl Typen zur Compilezeit als auch Sicherheit zur Laufzeit. Assertions liefern Ihnen nur eine Behauptung.

function parsePort(v: unknown): number {
  if (typeof v === 'number' && Number.isInteger(v)) return v;
  throw new Error('invalid port');
}
console.log(parsePort(8080));

Kurzer Test

Testen Sie Ihr Verständnis von Assertions und Type Guards.

Rückblick: Assertions und Guards

Sie haben gelernt:

Type Guards (value is T) weisen einen Typ zur Laufzeit nach und ermöglichen Verzweigungen.
Assertion-Funktionen (asserts value is T) lösen bei einem Fehler einen Fehler aus und grenzen den Typ anschließend ein.
Einfache as-Assertions behaupten lediglich einen Typ und bieten keine Sicherheit zur Laufzeit.
Bevorzugen Sie zur Laufzeit geprüfte Werkzeuge. Reservieren Sie Assertions für Fälle, die sich nicht anders eingrenzen lassen.

Im nächsten Kurs geht es um Optional Chaining und Nullish Coalescing.

function isPositive(v: unknown): v is number {
  return typeof v === 'number' && v > 0;
}
console.log(isPositive(5), isPositive(-1));

Häufig gestellte Fragen

Ist die Lektion „Assertions und Type Guards“ kostenlos?

Ja — der vollständige Text von „Assertions und Type Guards“ 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 „Assertions und Type Guards“?

Bevorzugen Sie, wo möglich, Laufzeitprüfungen gegenüber Assertions. 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 4 von 4.

Wie lange dauert die Lektion „Assertions und Type Guards“?

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