TypeScript Academy · Lektion

Eingabevalidierung zur Compile-Zeit

Lehnen Sie fehlerhafte DSL-Ausdrücke bereits vor der Laufzeit ab.

Eingabevalidierung zur Compile-Zeit 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.

Eingabevalidierung zur Compilezeit

DSLs auf Typebene können fehlerhafte Ausdrücke vor der Laufzeit zurückweisen. Mit Template-Literal- und Conditional Types validieren wir die Struktur eines Strings auf Typebene und lehnen ungültige Eingaben ab.

Beispiel: Eine kleine Selektorsprache

Stellen Sie sich vor, Sie akzeptieren Strings wie "user.name" oder "order.items.length". "user." oder ".name" sollen bereits zur Compilezeit zurückgewiesen werden.

Mit Template-Literals parsen

Template-Literal-Typen teilen einen String mithilfe von infer in Bestandteile auf – die Grundlage des Parsens zur Compilezeit. Das eigentliche Muster ist durch Backticks begrenzt (Head dot Tail with infer); wir bezeichnen diesen Split-Matcher als DotSplit.

// Real TS: backtick pattern matching Head, ".", Tail.

type Split<S extends string> =
  S extends DotSplit<infer Head, infer Tail>
    ? [Head, ...Split<Tail>]
    : [S];

type P = Split<"a.b.c">; // ["a", "b", "c"]

Jedes Segment validieren

Ein Conditional Type prüft, dass kein Segment leer ist. Ein leeres Segment kennzeichnet die Eingabe als ungültig. Dasselbe DotSplit-Muster (ein Backtick-Template-Literal im echten Code) steuert die Rekursion.

type NonEmpty<S extends string> = S extends "" ? false : true;

type Valid<S extends string> =
  S extends DotSplit<infer H, infer T>
    ? H extends "" ? false : Valid<T>
    : NonEmpty<S>;

type V1 = Valid<"a.b">;  // true
type V2 = Valid<"a.">;   // false

Die API anhand der Gültigkeit absichern

Verwenden Sie den Gültigkeitstyp, um einen Funktionsparameter einzuschränken: Gültige Zeichenfolgen behalten ihren Typ; ungültige werden zu never aufgelöst, sodass der Aufruf nicht kompiliert werden kann.

declare function path<S extends string>(
  p: Valid<S> extends true ? S : never
): void;

path("user.name"); // ok
path("user.");     // Error: argument is never

Unbekannte Tokens ablehnen

Sie können auch die zulässigen Zeichen einschränken. Stimmen Sie nur bekannte Segmentmuster ab; alles andere wird zu einem ablehnenden Typ.

type Allowed = "user" | "order" | "name" | "items";
type CheckSeg<S extends string> = S extends Allowed ? true : false;

Operatoren validieren

Für eine Ausdrucks-DSL wie "age > 18" stimmen Sie den Operator mit einem Template-Literal ab und stellen Sie sicher, dass er in einer zulässigen Menge enthalten ist. Der Matcher (linkes Leerzeichen O rechtes Leerzeichen) ist im echten Code ein Backtick-Template-Literal; wir bezeichnen ihn als CondMatch.

type Op = ">" | "<" | "=" | ">=" | "<=";

// Real TS: backtick pattern -> left, " ", infer O, " ", right.
type IsCond<S extends string> =
  S extends CondMatch<infer O>
    ? O extends Op ? true : false
    : false;

type C1 = IsCond<"age > 18">; // true
type C2 = IsCond<"age ! 18">; // false

Prüfungen kombinieren

Praxisnahe Validatoren kombinieren mehrere Bedingungen: nicht leere Segmente, zulässige Tokens und eine ausgewogene Struktur. Jede Bedingung ist ein bedingter Typ; kombinieren Sie sie mit Hilfstypen nach dem Vorbild logischer Operatoren.

type And<A, B> = A extends true ? (B extends true ? true : false) : false;

Grenzen der Rekursion

Rekursion auf Typebene unterliegt Tiefenbeschränkungen. Bei sehr langen Zeichenfolgen gibt der Compiler möglicherweise den Fehler "type instantiation is excessively deep" aus. Begrenzen Sie die Länge der zu analysierenden Eingaben oder vereinfachen Sie die Grammatik.

Besser als Parsing zur Laufzeit

Ein Parser zur Laufzeit meldet sich erst, wenn die fehlerhafte Zeichenfolge ausgewertet wird. Die Validierung zur Compilezeit lehnt das Literal bereits bei der Eingabe ab – mit vollständigem Feedback im Editor und ohne Kosten zur Laufzeit.

Warum das wichtig ist

Viele DSLs akzeptieren Zeichenfolgeneingaben (Pfade, Abfragen, Formate). Wenn Sie ihre Struktur im Typsystem validieren, werden Tippfehler und fehlerhafte Ausdrücke vor der Programmausführung erkannt. Dadurch wird eine ganze Klasse von Laufzeitfehlern zu Compilerfehlern.

Kurztest

Überprüfen Sie Ihr Verständnis der Eingabevalidierung zur Compilezeit.

Zusammenfassung

Sie haben DSL-Eingaben vor der Laufzeit validiert, indem Sie Zeichenfolgenliterale mit Template-Literal-Typen und infer analysiert und anschließend Segmente und Operatoren mit bedingten Typen überprüft haben. Wenn Sie einen Funktionsparameter an den Gültigkeitstyp binden, werden fehlerhafte Ausdrücke zu never aufgelöst und können nicht kompiliert werden. Dabei müssen Sie die Grenzen der Rekursion berücksichtigen.

Häufig gestellte Fragen

Ist die Lektion „Eingabevalidierung zur Compile-Zeit“ kostenlos?

Ja — der vollständige Text von „Eingabevalidierung zur Compile-Zeit“ 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 „Eingabevalidierung zur Compile-Zeit“?

Lehnen Sie fehlerhafte DSL-Ausdrücke bereits vor der Laufzeit ab. 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 „Eingabevalidierung zur Compile-Zeit“?

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