Validazione degli input in fase di compilazione
Rifiuti le espressioni DSL malformate prima del runtime.
Validazione degli input in fase di compilazione è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.
Validazione degli input in fase di compilazione
I DSL a livello di tipo possono rifiutare espressioni non valide prima del runtime. Usando template literal e tipi condizionali, validiamo la struttura di una stringa a livello di tipo e rifiutiamo gli input non validi.
Esempio: un piccolo linguaggio per i selettori
Immagini di accettare stringhe come "user.name" o "order.items.length". Vogliamo rifiutare "user." o ".name" in fase di compilazione.
Analizzare con i template literal
I tipi template literal dividono una stringa in parti usando infer, la base dell'analisi in fase di compilazione. Lo schema reale usa un delimitatore backtick (Head dot Tail con infer); qui indichiamo questo matcher di divisione come 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"]Validare ogni segmento
Un tipo condizionale verifica che nessun segmento sia vuoto. Un segmento vuoto indica che l'input non è valido. Lo stesso schema DotSplit, un template literal delimitato da backtick nel codice reale, guida la ricorsione.
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.">; // falseVincolare l'API alla validità
Usi il tipo di validità per vincolare un parametro di funzione: le stringhe valide mantengono il proprio tipo; quelle non valide diventano never, quindi la chiamata non supera la compilazione.
declare function path<S extends string>(
p: Valid<S> extends true ? S : never
): void;
path("user.name"); // ok
path("user."); // Error: argument is neverRifiutare i token sconosciuti
Può limitare anche i caratteri consentiti. Verifichi solo i pattern di segmento conosciuti; tutto il resto viene ridotto a un tipo che rifiuta il valore.
type Allowed = "user" | "order" | "name" | "items";
type CheckSeg<S extends string> = S extends Allowed ? true : false;Validare gli operatori
Per un DSL di espressioni come "age > 18", verifichi l'operatore con un template literal e si assicuri che appartenga a un insieme consentito. Il matcher (spazio sinistro O spazio destro) è un template literal con i backtick nel codice reale; qui lo indichiamo con 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">; // falseCombinare i controlli
I validatori reali intersecano diverse condizioni: segmenti non vuoti, token consentiti, struttura bilanciata. Ognuna è un tipo condizionale; le combini con tipi helper in stile logico.
type And<A, B> = A extends true ? (B extends true ? true : false) : false;Limiti della ricorsione
La ricorsione a livello di tipo ha limiti di profondità. Per le stringhe molto lunghe, il compilatore può segnalare che "l'istanza del tipo è eccessivamente profonda". Mantenga entro limiti ragionevoli gli input analizzati oppure semplifichi la grammatica.
Meglio del parsing a runtime
Un parser a runtime segnala il problema solo quando la stringa non valida viene valutata. La validazione a compile time rifiuta il literal nel momento stesso in cui lo digita, offrendo un feedback completo nell'editor e nessun costo a runtime.
Perché è importante
Molti DSL accettano input stringa (percorsi, query, formati). Validarne la struttura nel sistema dei tipi permette di rilevare refusi ed espressioni malformate prima dell'esecuzione del programma, trasformando una categoria di errori a runtime in errori di compilazione.
Verifica rapida
Verifichi la sua comprensione della validazione degli input a compile time.
Riepilogo
Ha validato l'input di un DSL prima del runtime analizzando i literal stringa con i template literal type e infer, quindi controllando segmenti e operatori con i tipi condizionali. Vincolare un parametro di funzione al tipo di validità fa sì che le espressioni malformate diventino never e non superino la compilazione, tenendo conto dei limiti della ricorsione.
Domande Frequenti
La lezione «Validazione degli input in fase di compilazione» è gratuita?
Sì — il testo completo di «Validazione degli input in fase di compilazione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.
Cosa imparerò in «Validazione degli input in fase di compilazione»?
Rifiuti le espressioni DSL malformate prima del runtime. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare TypeScript Academy?
Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Validazione degli input in fase di compilazione»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?
Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Che cos’è una DSL a livello di tipo
- Progettare una DSL fluente per le query
- Validazione degli input in fase di compilazione
- Messaggi di errore nelle DSL a livello di tipo