TypeScript Academy · leksjon

Parsing med template literals

Trekk ut strukturerte data fra strenger ved hjelp av infer.

Leksjon 3 av 413 trinn

Parsing med template literals er en gratis leksjon i TypeScript Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i TypeScript Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.

Fra oppdeling til struktur

Oppdeling gir en tuppel med deler. Parsing går lenger: det hentes ut navngitte, strukturerte data fra en strengtype. Template literal-mønstre med flere infer-variabler brukes til å hente ut delene som er interessante.

Notasjon: I ekte TypeScript skrives template literal-typer med backtick-avgrensede strenger som inneholder plassholdere med dollar og krøllparenteser. I disse kodeutdragene vises dette mønsteret som Tpl<...>, der hver del listes i rekkefølge; et backtick-mønster som samsvarer med det bokstavelige prefikset etterfulgt av Rest, vises for eksempel som 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' }

Flere infereringspunkter

Étt mønster kan hente ut flere felt samtidig. For å parse "GET /users" infereres metoden og stien i én betinget type.

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' }

Avgrense infererte deler

En inferert variabel kan begrenses med extends direkte i uttrykket, slik at den bare matcher bestemte former. Her må metoden være et kjent verb.

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' }

Parsing av nøkkel-verdi-par

Kombiner oppdeling og parsing: del en spørringsstreng opp i par, og parse deretter hvert par til en nøkkel og en verdi. Resultatet er en tuppel med strukturerte oppføringer.

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']

Bygge et objekt fra par

Fold en tuppel med nøkkel-verdi-par inn i en objekttype ved hjelp av en mapped/intersection-akkumulator. Hvert par legger til én egenskap.

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" }

Parsing av en spørringsstreng

Sett det hele sammen: del ved hjelp av "&", parse hver del ved hjelp av "=", og bygg deretter objektet. Kompilatoren kjenner nå de nøyaktige nøklene i en spørringsstrengliteral.

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

Hente ut tall

Infererte deler er alltid strengliteraltyper. For å behandle en del som et tall kontrolleres det om den matcher et numerisk mønster, eller den mappes gjennom en begrensning som bare tillater sifre. Verdien forblir en literaltype.

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

Valgfrie segmenter

Bruk en union av mønstre for å håndtere valgfrie deler. Prøv det mer omfattende mønsteret først, og fall tilbake til det enklere hvis det ikke matcher.

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' }

Mellomrom og kanttilfeller

Virkelige strenger inneholder ofte overflødige mellomrom. Sett parseren sammen med Trim fra forrige leksjon, slik at innledende og avsluttende mellomrom ikke ødelegger de uthentede feltene.

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

Hvorfor dette er kraftig

Parsing med template literals lar kompilatoren forstå formater: datoer, ruter, miljønøkler og SQL-fragmenter. Strenger med skrivefeil blir kompileringsfeil, og nedstrøms typer kan avhenge av den parsede strukturen. Strengliteralen blir en typet verdi.

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' }

Sammensetning av parsere

Akkurat som kombinatorer på verdinivå kan parserne på typenivå settes sammen. Del først opp, parse deretter hver del, og sett til slutt sammen et objekt. Hvert trinn er en liten betinget type, og sammen danner de en komplett, typet parser.

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

Hurtigsjekk

Test forståelsen av parsing med template literals.

Besvar den i den interaktive leksjonen

Oppsummering

Strukturerte data ble hentet ut fra strengtyper.

Flere infer-punkter henter ut navngitte felt i ett mønster.
Infererte deler kan avgrenses med extends direkte i uttrykket.
Split, Pair og FromPairs settes sammen til en spørringsparser.
Trim og numeriske kontroller håndterer kanttilfeller.

Neste trinn: en komplett liten ruteparser.

Gratis å komme i gang

Lær deg TypeScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 101
Leksjoner: 352

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Parsing med template literals» gratis?

Ja – hele teksten i «Parsing med template literals» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av TypeScript Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Parsing med template literals»?

Trekk ut strukturerte data fra strenger ved hjelp av infer. Du øver på TypeScript Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med TypeScript Academy?

Ingen tidligere erfaring er nødvendig. TypeScript Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Parsing med template literals»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne TypeScript Academy-leksjonen?

Ja. Alle TypeScript Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til TypeScript Academy