Divisione di stringhe a livello di tipo
Divida stringhe in tuple all’interno del sistema dei tipi.
Divisione di stringhe a livello di tipo è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 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.
Tipi template literal
Il sistema dei tipi può confrontare i pattern dei tipi literal di stringa usando i template literal type combinati con infer. Questo è lo strumento fondamentale per analizzare le stringhe a livello di tipo.
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 StartsWithA<S> = S extends Tpl<'a', string> ? true : false;
// Tpl<'a', string> is a backtick template literal type: 'a' then anything
type X = StartsWithA<'abc'>; // true
type Y = StartsWithA<'bcd'>; // falseInferenza di un suffisso
Inserisca infer all'interno del template per catturare una parte della stringa. Qui catturiamo tutto ciò che segue un "a" iniziale.
type AfterA<S> = S extends Tpl<'a', infer Rest> ? Rest : never;
// Tpl<'a', Rest> captures everything after a leading 'a'
type X = AfterA<'abc'>; // 'bc'Suddivisione su un delimitatore
Per suddividere una stringa alla prima occorrenza di un separatore, confronti il pattern "head, separator, tail" e inferisca entrambi i lati. Viene usata la prima corrispondenza perché l'inferenza è avida da sinistra per head.
type SplitOnce<S, Sep extends string> =
S extends Tpl<infer Head, Sep, infer Tail>
? [Head, Tail]
: [S];
// Tpl<Head, Sep, Tail> matches up to the first separator
type X = SplitOnce<'a-b-c', '-'>; // ['a', 'b-c']Suddivisione ricorsiva
Per suddividere la stringa in tutte le sue parti, applichi la ricorsione a tail. Raccolga ogni head in una tupla finché non rimangono separatori.
type Split<S extends string, Sep extends string> =
S extends Tpl<infer Head, Sep, infer Tail>
? [Head, ...Split<Tail, Sep>]
: [S];
// recurse on Tail until no separator remains
type X = Split<'a.b.c', '.'>; // ['a', 'b', 'c']Seguire la ricorsione
Segua l'esecuzione di Split<"a.b.c", ".">:
- Head "a", Tail "b.c" -> ["a", ...Split<"b.c">]
- Head "b", Tail "c" -> ["b", ...Split<"c">]
- "c" non contiene ".", caso base -> ["c"]
Risultato: ["a", "b", "c"].
type X = Split<"one,two", ",">; // ["one", "two"]
type Y = Split<"x/y/z", "/">; // ["x", "y", "z"]Gestione dei segmenti vuoti
La suddivisione può produrre stringhe vuote quando i separatori sono adiacenti o si trovano ai margini. Il pattern continua a funzionare, inferendo un Head o un Tail vuoto.
type X = Split<"a,,b", ",">; // ["a", "", "b"]
type Y = Split<",a", ",">; // ["", "a"]Ricongiungere le parti
L'operazione inversa della suddivisione è join: percorra una tupla di stringhe e le concateni usando un separatore e un template literal. Questa operazione si abbina naturalmente a split.
type Join<T extends string[], Sep extends string> =
T extends [infer H extends string, ...infer R extends string[]]
? R extends [] ? H : Tpl<H, Sep, Join<R, Sep>>
: '';
// Tpl<...> denotes a template literal type concatenation
type X = Join<['a', 'b', 'c'], '-'>; // 'a-b-c'Rimozione degli spazi bianchi
Le utilità per le stringhe si possono comporre. Un tipo Trim rimuove gli spazi iniziali e finali eliminando ripetutamente uno spazio tramite l'inferenza dei template.
type TrimLeft<S extends string> =
S extends Tpl<' ', infer R> ? TrimLeft<R> : S;
type TrimRight<S extends string> =
S extends Tpl<infer R, ' '> ? TrimRight<R> : S;
type Trim<S extends string> = TrimRight<TrimLeft<S>>;
// Tpl<' ', R> strips a leading space; Tpl<R, ' '> strips a trailing one
type X = Trim<' hi '>; // 'hi'Sostituzione di sottostringhe
Replace funziona suddividendo la stringa attorno all'elemento cercato e ricomponendola con la sostituzione, il tutto tramite inferenza dei template e ricorsione.
type ReplaceAll<S extends string, From extends string, To extends string> =
S extends Tpl<infer A, From, infer B>
? Tpl<A, To, ReplaceAll<B, From, To>>
: S;
// split around From, then rejoin with To via template literal types
type X = ReplaceAll<'a-b-c', '-', '_'>; // 'a_b_c'Perché la suddivisione è importante
La suddivisione è il fondamento dell'analisi strutturata. Le route vengono suddivise su "/", le stringhe di query su "&" e le righe CSV su ",". Con Split può trasformare un tipo stringa piatto in una tupla da elaborare elemento per elemento.
type Segments = Split<"users/42/posts", "/">; // ["users", "42", "posts"]Attenzione alla profondità
La ricorsione sulle stringhe a livello di tipo è limitata dalla profondità massima del compilatore. Stringhe molto lunghe o con molti separatori possono superare questo limite. Per gli input tipici, come percorsi e piccoli formati, funziona senza problemi.
type Ok = Split<"a/b/c/d/e", "/">; // fine for small stringsVerifica rapida
Verifichi la Sua comprensione della suddivisione delle stringhe a livello di tipo.
Riepilogo
Ha suddiviso stringhe interamente a livello di tipo.
- I template literal type insieme a
inferconfrontano e catturano le parti delle stringhe. SplitOncesuddivide alla prima occorrenza del separatore; la ricorsione produce unoSplitcompleto.- Join, Trim e ReplaceAll si compongono a partire dagli stessi strumenti.
Prossimo argomento: estrarre dati strutturati dai tipi stringa.
Domande Frequenti
La lezione «Divisione di stringhe a livello di tipo» è gratuita?
Sì — il testo completo di «Divisione di stringhe a livello di tipo» è 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 «Divisione di stringhe a livello di tipo»?
Divida stringhe in tuple all’interno del sistema dei tipi. 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 2 di 4.
Quanto tempo richiede la lezione «Divisione di stringhe a livello di tipo»?
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