0Pricing
TypeScript Academy · Lekcja

Parsowanie za pomocą literałów szablonowych

Wyodrębniaj ustrukturyzowane dane ze stringów za pomocą infer

Parsowanie za pomocą literałów szablonowych to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Od dzielenia do struktury

Dzielenie daje krotkę części. Parsowanie idzie o krok dalej: wyodrębnia nazwane, ustrukturyzowane dane z typu ciągu znaków. Używamy wzorców literałów szablonowych z wieloma zmiennymi infer, aby wyodrębnić interesujące nas elementy.

Notacja: w rzeczywistym TypeScript typy literałów szablonowych zapisuje się jako ciągi ograniczone znakami backtick, zawierające miejsca wstawiania w składni dollar-brace. W tych fragmentach pokazujemy ten wzorzec jako Tpl<...>, wymieniając poszczególne części w kolejności; na przykład szablon backtick dopasowujący najpierw literał będący prefiksem, a następnie Rest, jest przedstawiony jako 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' }

Wiele miejsc wnioskowania

Pojedynczy wzorzec może jednocześnie przechwycić kilka pól. Aby sparsować "GET /users", można w jednym typie warunkowym wywnioskować metodę i ścieżkę.

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

Zawężanie wywnioskowanych części

Można wbudować ograniczenie wywnioskowanej zmiennej za pomocą extends, dzięki czemu będzie ona dopasowywana tylko do określonych kształtów. W tym przykładzie metoda musi być znaną metodą.

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

Parsowanie par klucz-wartość

Połącz dzielenie i parsowanie: podziel ciąg zapytania na pary, a następnie sparsuj każdą parę na klucz i wartość. Wynikiem jest krotka ustrukturyzowanych elementów.

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

Budowanie obiektu z par

Przekształć krotkę par klucz-wartość w typ obiektu za pomocą akumulatora opartego na typie mapowanym i przecięciu. Każda para dodaje jedną właściwość.

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

Parsowanie ciągu zapytania

Połącz wszystko: podziel ciąg przy "&", sparsuj każdy fragment przy "=", a następnie zbuduj obiekt. Kompilator zna teraz dokładne klucze literału będącego ciągiem zapytania.

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

Wyodrębnianie liczb

Wywnioskowane części zawsze są typami literałów tekstowych. Aby traktować część jako liczbę, należy sprawdzić, czy pasuje do wzorca liczbowego, albo przekształcić ją za pomocą ograniczenia dopuszczającego wyłącznie cyfry. Wartość pozostaje typem literału.

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

Opcjonalne segmenty

Użyj unii wzorców, aby obsłużyć opcjonalne części. Najpierw dopasuj bogatszy wzorzec; jeśli nie pasuje, użyj prostszego.

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

Białe znaki i przypadki brzegowe

Rzeczywiste ciągi znaków zawierają zbędne spacje. Połącz parser z typem Trim z poprzedniej lekcji, aby początkowe i końcowe białe znaki nie zniekształcały wyodrębnionych pól.

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

Dlaczego to jest tak potężne

Parsowanie za pomocą literałów szablonowych pozwala kompilatorowi rozumieć formaty: daty, trasy, klucze środowiskowe czy fragmenty SQL. Niepoprawnie zapisane ciągi stają się błędami kompilacji, a typy zależne mogą opierać się na sparsowanej strukturze. Literał będący ciągiem znaków staje się typowaną wartością.

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

Kompozycja parserów

Tak jak kombinatory na poziomie wartości, parsery na poziomie typów można komponować. Najpierw podziel dane, następnie sparsuj każdą część, a na końcu zbuduj obiekt. Każdy krok jest małym typem warunkowym, a razem tworzą kompletny, typowany parser.

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

Szybki test

Proszę sprawdzić swoją wiedzę na temat parsowania za pomocą literałów szablonowych.

Podsumowanie

Wyodrębniono ustrukturyzowane dane z typów ciągów znaków.

  • Wiele punktów infer przechwytuje nazwane pola w jednym wzorcu.
  • Wywnioskowane części można zawężać za pomocą wbudowanego extends.
  • Split, Pair i FromPairs można komponować w parser zapytań.
  • Trim i sprawdzanie wartości liczbowych obsługują przypadki brzegowe.

Następnie: kompletny mini parser tras.

Często zadawane pytania

Czy lekcja „Parsowanie za pomocą literałów szablonowych” jest bezpłatna?

Tak — pełny tekst „Parsowanie za pomocą literałów szablonowych” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Parsowanie za pomocą literałów szablonowych”?

Wyodrębniaj ustrukturyzowane dane ze stringów za pomocą infer Ćwiczysz TypeScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Parsowanie za pomocą literałów szablonowych”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji TypeScript Academy?

Tak. Każda lekcja TypeScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Koncepcje kombinatorów parserów
  2. Dzielenie stringów na poziomie typów
  3. Parsowanie za pomocą literałów szablonowych
  4. Mini parser ścieżek routingu na poziomie typów
← Powrót do TypeScript Academy