TypeScript Academy · Lezione

Parsing con i template literal

Estragga dati strutturati dalle stringhe utilizzando infer.

Parsing con i template literal è 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.

Dalla suddivisione alla struttura

La suddivisione produce una tupla di parti. L'analisi va oltre: estrae dati denominati e strutturati da un tipo stringa. Usiamo pattern di template literal con più variabili infer per estrarre le parti che ci interessano.

Notazione: in TypeScript reale, i template literal type vengono scritti con stringhe delimitate da backtick che contengono segnaposto dollar-brace. In questi frammenti mostriamo questo pattern come Tpl<...>, elencando ogni parte nell'ordine; ad esempio, un template tra backtick che corrisponde al prefisso literal seguito da Rest appare come Tpl<'prefix', infer Rest>.

type KeyValue<S> =
  S extends Tpl<infer K, '=', infer V> ? { key: K; value: V } : never;
// Tpl<K, '=', V> matches K, an equals sign, then V

type X = KeyValue<'name=alice'>; // { key: 'name'; value: 'alice' }

Più punti di inferenza

Un singolo pattern può catturare più campi contemporaneamente. Per analizzare "GET /users", inferisca il metodo e il percorso in un'unica condizione.

type Request<S> =
  S extends Tpl<infer Method, ' ', infer Path>
    ? { method: Method; path: Path }
    : never;
// Tpl<Method, ' ', Path> matches the method, a space, then the path

type X = Request<'GET /users'>; // { method: 'GET'; path: '/users' }

Restringere le parti inferite

Può vincolare una variabile inferita con extends direttamente nel pattern, in modo che corrisponda solo a determinate forme. Qui il metodo deve essere un verbo noto.

type Method = 'GET' | 'POST';
type Parse<S> =
  S extends Tpl<(infer M extends Method), ' ', infer P>
    ? { method: M; path: P }
    : never;
// the inferred M is constrained to Method inside the template pattern

type X = Parse<'POST /x'>; // { method: 'POST'; path: '/x' }

Analisi di coppie chiave-valore

Combini suddivisione e analisi: suddivida una stringa di query in coppie, quindi analizzi ogni coppia separando chiave e valore. Il risultato è una tupla di elementi strutturati.

type Pair<S> =
  S extends Tpl<infer K, '=', infer V> ? [K, V] : [S, ''];
// Tpl<K, '=', V> splits a 'key=value' string literal type

type X = Pair<'page=2'>; // ['page', '2']

Costruire un oggetto dalle coppie

Converta una tupla di coppie chiave-valore in un tipo oggetto usando un accumulatore basato su mapped type e intersezioni. Ogni coppia aggiunge una proprietà.

type FromPairs<T extends [string, string][]> =
  T extends [[infer K extends string, infer V], ...infer R extends [string, string][]]
    ? { [P in K]: V } & FromPairs<R>
    : {};

type X = FromPairs<[["a", "1"], ["b", "2"]]>; // { a: "1" } & { b: "2" }

Analisi di una stringa di query

Metta insieme i passaggi: suddivida su "&", analizzi ogni parte su "=", quindi costruisca l'oggetto. Il compilatore conosce ora le chiavi esatte di un literal di stringa di query.

type ParseQuery<S extends string> =
  FromPairs<{ [I in keyof SplitAmp<S>]: Pair<SplitAmp<S>[I] & string> }>;
// where SplitAmp splits on "&" (from previous lesson)

Estrarre numeri

Le parti inferite sono sempre tipi literal di stringa. Per trattare una parte come numero, verifichi se corrisponde a un pattern numerico oppure la faccia passare attraverso un vincolo che ammette solo cifre. Il valore rimane un tipo literal.

type IsNumeric<S extends string> =
  S extends Tpl<number> ? true : false;
// Tpl<number> is a template literal type that matches any numeric string

type X = IsNumeric<'42'>; // true
type Y = IsNumeric<'4a'>; // false

Segmenti opzionali

Usi un'unione di pattern per gestire le parti opzionali. Provi prima il pattern più ricco; se non corrisponde, ricorra a quello più semplice.

type ParsePath<S> =
  S extends Tpl<infer Base, '?', infer Query>
    ? { base: Base; query: Query }
    : { base: S; query: '' };
// Tpl<Base, '?', Query> matches an optional query after a question mark

type X = ParsePath<'/x?a=1'>; // { base: '/x'; query: 'a=1' }

Spazi bianchi e casi limite

Le stringhe reali contengono spazi superflui. Componga il parser con Trim della lezione precedente, così gli spazi bianchi iniziali e finali non altereranno i campi estratti.

type CleanKey<S extends string> = Trim<S>;
// Apply Trim to each inferred segment before using it

Perché è così potente

L'analisi tramite template literal permette al compilatore di comprendere i formati: date, route, chiavi di ambiente e frammenti SQL. Le stringhe errate diventano errori di compilazione e i tipi delle fasi successive possono dipendere dalla struttura analizzata. Il literal di stringa diventa un valore tipizzato.

type Event<S> =
  S extends Tpl<infer Domain, ':', infer Action>
    ? { domain: Domain; action: Action }
    : never;
// Tpl<Domain, ':', Action> matches 'domain:action'
type X = Event<'user:created'>; // { domain: 'user'; action: 'created' }

Comporre i parser

Proprio come i combinatori a livello di valore, anche i parser a livello di tipo si possono comporre. Suddivida, analizzi ogni parte, quindi assembli un oggetto. Ogni passaggio è un piccolo conditional type e, insieme, formano un parser completo e tipizzato.

// Split -> Pair -> FromPairs is a parser pipeline at the type level

Verifica rapida

Verifichi la Sua comprensione dell'analisi tramite template literal.

Riepilogo

Ha estratto dati strutturati dai tipi stringa.

Più punti infer catturano campi denominati in un unico pattern.
Le parti inferite possono essere ristrette con extends direttamente nel pattern.
Split, Pair e FromPairs si compongono in un parser di query.
Trim e i controlli numerici gestiscono i casi limite.

Prossimo argomento: un parser completo per mini route.

Domande Frequenti

La lezione «Parsing con i template literal» è gratuita?

Sì — il testo completo di «Parsing con i template literal» è 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 «Parsing con i template literal»?

Estragga dati strutturati dalle stringhe utilizzando infer. 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 «Parsing con i template literal»?

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

Concetti dei parser combinator
Divisione di stringhe a livello di tipo
Parsing con i template literal
Un mini parser di route a livello di tipo

← Torna a TypeScript Academy