0Pricing
TypeScript Academy · Lekcja

Dzielenie stringów na poziomie typów

Dziel stringi na krotki w systemie typów

Dzielenie stringów na poziomie typów to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 2 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.

Typy literałów szablonowych

System typów może dopasowywać wzorce typów literałów tekstowych za pomocą typów literałów szablonowych połączonych z infer. To podstawowe narzędzie do parsowania ciągów znaków na poziomie typów.

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 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'>; // false

Wnioskowanie przyrostka

Umieść infer wewnątrz szablonu, aby przechwycić część ciągu znaków. W tym przykładzie przechwytujemy wszystko po początkowym "a".

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'

Dzielenie według separatora

Aby podzielić ciąg znaków przy pierwszym wystąpieniu separatora, dopasuj wzorzec „początek, separator, koniec” i wywnioskuj obie strony. Wygrywa pierwsze dopasowanie, ponieważ wnioskowanie dla początku jest zachłanne od lewej strony.

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

Rekurencyjne dzielenie

Aby podzielić ciąg na wszystkie części, wywołuj parser rekurencyjnie dla końca. Zbieraj każdy początek do krotki, aż nie pozostanie żaden separator.

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

Śledzenie rekurencji

Prześledź Split<"a.b.c", ".">:

  • Head "a", Tail "b.c" -> ["a", ...Split<"b.c">]
  • Head "b", Tail "c" -> ["b", ...Split<"c">]
  • "c" has no ".", base case -> ["c"]

Wynik: ["a", "b", "c"].

type X = Split<"one,two", ",">; // ["one", "two"]
type Y = Split<"x/y/z", "/">; // ["x", "y", "z"]

Obsługa pustych segmentów

Dzielenie może tworzyć puste ciągi, gdy separatory znajdują się obok siebie lub na krawędziach. Wzorzec nadal pasuje, wywnioskowując pusty Head lub Tail.

type X = Split<"a,,b", ",">; // ["a", "", "b"]
type Y = Split<",a", ",">;   // ["", "a"]

Ponowne łączenie

Odwrotnością split jest join: przejdź po krotce ciągów znaków i połącz je separatorem za pomocą literału szablonowego. Te operacje naturalnie się uzupełniają.

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'

Usuwanie białych znaków

Narzędzia do pracy z ciągami znaków można komponować. Typ Trim usuwa początkowe i końcowe spacje, wielokrotnie usuwając spację za pomocą wnioskowania z szablonu.

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'

Zastępowanie podciągów

Replace działa przez podzielenie ciągu wokół szukanego elementu i ponowne połączenie części z zamiennikiem — wszystko za pomocą wnioskowania z szablonu i rekurencji.

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'

Dlaczego dzielenie ma znaczenie

Dzielenie jest podstawą parsowania danych o strukturze. Trasy dzieli się przy "/", ciągi zapytań przy "&", a wiersze CSV przy ",". Za pomocą Split można przekształcić płaski typ ciągu znaków w krotkę, której elementy da się przetwarzać pojedynczo.

type Segments = Split<"users/42/posts", "/">; // ["users", "42", "posts"]

Uwaga na głębokość

Rekurencja ciągów znaków na poziomie typów jest ograniczona limitem głębokości kompilatora. Bardzo długie ciągi lub duża liczba separatorów może przekroczyć ten limit. W przypadku typowych danych wejściowych, takich jak ścieżki i małe formaty, działa ona bez problemów.

type Ok = Split<"a/b/c/d/e", "/">; // fine for small strings

Szybki test

Proszę sprawdzić swoją wiedzę na temat dzielenia ciągów znaków na poziomie typów.

Podsumowanie

Podzielono ciągi znaków wyłącznie za pomocą typów.

  • Typy literałów szablonowych wraz z infer dopasowują i przechwytują części ciągów znaków.
  • SplitOnce dzieli przy pierwszym separatorze, a rekurencja tworzy pełny typ Split.
  • Join, Trim i ReplaceAll można komponować za pomocą tych samych narzędzi.

Następnie: wyodrębnianie ustrukturyzowanych danych z typów ciągów znaków.

Często zadawane pytania

Czy lekcja „Dzielenie stringów na poziomie typów” jest bezpłatna?

Tak — pełny tekst „Dzielenie stringów na poziomie typów” 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 „Dzielenie stringów na poziomie typów”?

Dziel stringi na krotki w systemie typów Ć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 2 z 4.

Ile czasu zajmuje lekcja „Dzielenie stringów na poziomie typów”?

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