TypeScript Academy · Les

Inputvalidatie tijdens het compileren

Wijs verkeerd gevormde DSL-uitdrukkingen af voordat ze tijdens runtime worden uitgevoerd

Les 3 van 413 stappen

Inputvalidatie tijdens het compileren is een gratis TypeScript Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 4 lessen.

Invoer valideren tijdens het compileren

DSL's op typeniveau kunnen ongeldige expressies al vóór de uitvoering afwijzen. Met sjabloonletterlijke typen en voorwaardelijke typen valideren we de structuur van een tekenreeks op typeniveau en weigeren we ongeldige invoer.

Voorbeeld: een kleine selectietaal

Stel dat je tekenreeksen zoals "user.name" of "order.items.length" accepteert. We willen "user." of ".name" tijdens het compileren afwijzen.

Parseren met sjabloonliteralen

Met sjabloonletterlijke typen splits je een tekenreeks met behulp van infer in delen. Dat vormt de basis van parseren tijdens het compileren. Het echte patroon wordt door backticks begrensd (Head punt Tail met infer); we geven dit patroon voor het splitsen de naam 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"]

Elk segment valideren

Een voorwaardelijk type controleert of geen enkel segment leeg is. Een leeg segment maakt de invoer ongeldig. Hetzelfde DotSplit-patroon, in echte code een sjabloonliteral met backticks, stuurt de recursie aan.

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

De API laten afhangen van geldigheid

Gebruik het geldigheidstype om een functieparameter te beperken: geldige tekenreeksen behouden hun type; ongeldige tekenreeksen worden never, waardoor de aanroep niet compileert.

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

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

Onbekende tokens afwijzen

Je kunt ook toegestane tekens beperken. Vergelijk alleen bekende segmentpatronen; al het andere valt terug naar een afwijzend type.

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

Operators valideren

Voor een expressie-DSL zoals "age > 18" vergelijk je de operator met een template literal en controleer je of deze in een toegestane verzameling staat. De matcher (linker spatie O spatie rechter) is in echte code een template literal met backticks; hier noemen we deze 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

Controles combineren

Echte validaties combineren meerdere voorwaarden: niet-lege segmenten, toegestane tokens en een gebalanceerde structuur. Elke voorwaarde is een conditioneel type; combineer ze met hulpertypen die werken als logische operatoren.

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

Grenzen voor recursie

Voor recursie op typeniveau gelden dieptelimieten. Bij zeer lange tekenreeksen kan de compiler een fout geven met “type-instantie is buitensporig diep”. Beperk geparseerde invoer of vereenvoudig de grammatica.

Beter dan parseren tijdens uitvoering

Een parser tijdens uitvoering klaagt pas wanneer de ongeldige tekenreeks wordt geëvalueerd. Validatie tijdens compilatie wijst de letterlijke tekenreeks af zodra je deze typt, met volledige terugkoppeling van de editor en zonder kosten tijdens uitvoering.

Waarom dit belangrijk is

Veel DSL's accepteren tekenreeksinvoer (paden, query's, indelingen). Door hun structuur in het typesysteem te valideren, ontdek je typefouten en verkeerd gevormde expressies voordat het programma wordt uitgevoerd. Zo verander je een categorie uitvoeringsfouten in compileerfouten.

Korte controle

Controleer of je begrijpt hoe invoer tijdens het compileren wordt gevalideerd.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt DSL-invoer vóór uitvoering gevalideerd door letterlijke tekenreeksen te parseren met template literal-typen en infer, en vervolgens segmenten en operators te controleren met conditionele typen. Door een functieparameter te laten afhangen van het geldigheidstype, worden verkeerd gevormde expressies never en compileren ze niet; houd daarbij rekening met recursielimieten.

Gratis beginnen

Leer TypeScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 101
Lessen: 352

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Inputvalidatie tijdens het compileren” gratis?

Ja — de volledige tekst van “Inputvalidatie tijdens het compileren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 4 lessen.

Wat leer ik in “Inputvalidatie tijdens het compileren”?

Wijs verkeerd gevormde DSL-uitdrukkingen af voordat ze tijdens runtime worden uitgevoerd Je oefent met TypeScript Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met TypeScript Academy te beginnen?

Ervaring vooraf is niet nodig. TypeScript Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Inputvalidatie tijdens het compileren”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over TypeScript Academy?

Ja. Elke les over TypeScript Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar TypeScript Academy