TypeScript Academy · Lektion

Validering av indata vid kompilering

Avvisa felaktiga DSL-uttryck innan körning.

Lektion 3 av 413 steg

Validering av indata vid kompilering är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Indatavalidering vid kompilering

DSL:er på typnivå kan avvisa felaktiga uttryck före körning. Med malliteraltyper och villkorliga typer valideras en strängs struktur på typnivå, och ogiltig indata avvisas.

Exempel: Ett litet selektorspråk

Anta att strängar som "user.name" eller "order.items.length" accepteras. "user." eller ".name" ska avvisas vid kompilering.

Tolka med malliteraler

Malliteraltyper delar upp en sträng i delar med hjälp av infer, vilket är grunden för tolkning vid kompilering. Det verkliga mönstret avgränsas med backticks (Head dot Tail med infer); den delningsmatcharen betecknas som 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"]

Validera varje segment

En villkorlig typ kontrollerar att inget segment är tomt. Ett tomt segment markerar indata som ogiltig. Samma DotSplit-mönster (en malliteral avgränsad med backticks i verklig kod) driver rekursionen.

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

Begränsa API:t till giltiga värden

Använd giltighetstypen för att begränsa en funktionsparameter: giltiga strängar behåller sin typ, medan ogiltiga strängar blir never, så anropet kan inte kompileras.

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

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

Avvisa okända token

Ni kan även begränsa vilka tecken som är tillåtna. Matcha endast kända segmentmönster; allt annat reduceras till en typ som avvisar värdet.

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

Validera operatorer

För en uttrycks-DSL som "age > 18" matchar Ni operatorn med en template literal och säkerställer att den ingår i en tillåten uppsättning. Matcharen (vänster mellanslag O mellanslag höger) är en template literal med backticks i den riktiga koden; här betecknar vi den som 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

Kombinera kontroller

Riktiga validatorer kombinerar flera villkor: icke-tomma segment, tillåtna token och balanserad struktur. Varje villkor är en villkorlig typ; kombinera dem med hjälptyper som fungerar på ett logikliknande sätt.

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

Rekursionsgränser

Rekursion på typnivå har djupgränser. För mycket långa strängar kan kompilatorn ge felet "type instantiation is excessively deep". Begränsa längden på indata eller förenkla grammatiken.

Bättre än parsning vid körning

En parser vid körning rapporterar bara problemet när den felaktiga strängen utvärderas. Validering vid kompilering avvisar literalvärdet så snart Ni skriver det, med full återkoppling i editorn och utan någon kostnad vid körning.

Varför detta är viktigt

Många DSL:er tar emot strängindata, till exempel sökvägar, frågor och format. När strukturen valideras i typsystemet upptäcks stavfel och felaktiga uttryck före programkörningen, så en kategori av körningsfel omvandlas till kompileringsfel.

Snabb kontroll

Kontrollera att Ni har förstått validering av indata vid kompilering.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni validerade DSL-indata före körning genom att parsa strängliteraler med template literal-typer och infer, och därefter kontrollera segment och operatorer med villkorliga typer. Genom att begränsa en funktionsparameter med giltighetstypen blir felaktiga uttryck never och kan inte kompileras. Tänk samtidigt på rekursionsgränserna.

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 101
Lektioner: 352

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Validering av indata vid kompilering” gratis?

Ja – hela texten till ”Validering av indata vid kompilering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Validering av indata vid kompilering”?

Avvisa felaktiga DSL-uttryck innan körning. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?

Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Validering av indata vid kompilering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?

Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till TypeScript Academy