TypeScript Academy · Lektion

String-opdeling på typeniveau

Opdel strenge i tupler i typesystemet

Lektion 2 af 413 trin

String-opdeling på typeniveau er en gratis TypeScript Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i TypeScript Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Template literal-typer

Typesystemet kan mønstermatche string literal-typer ved hjælp af template literal types kombineret med infer. Det er det centrale værktøj til strengparsing på typeniveau.

Notation: I rigtig TypeScript skrives template literal types med strenge afgrænset af backticks, som indeholder dollar-klamme-pladsholdere. I disse eksempler viser vi dette mønster som Tpl<...>, hvor hver del angives i rækkefølge; f.eks. vises en backtick-skabelon, der matcher det bogstavelige præfiks og derefter Rest, som 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

Udledning af et suffiks

Placér infer i skabelonen for at indfange en del af strengen. Her indfanger vi alt efter et indledende "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'

Opdeling ved en separator

Hvis du vil opdele en streng ved den første forekomst af en separator, skal du matche mønstret "hoved, separator, hale" og udlede begge sider. Det første match vinder, fordi udledningen er grådig fra venstre mod højre for hovedet.

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

Rekursiv opdeling

Hvis du vil opdele i alle dele, skal du rekursere over resten. Saml hvert førsteled i en tupel, indtil der ikke er flere separatorer.

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

Gennemgang af rekursionen

Følg Split<"a.b.c", ".">:

Head "a", Tail "b.c" -> ["a", ...Split<"b.c">]
Head "b", Tail "c" -> ["b", ...Split<"c">]
"c" har ingen ".", basistilfælde -> ["c"]

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

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

Håndtering af tomme segmenter

Opdeling kan producere tomme strenge, når separatorer står ved siden af hinanden eller ved kanterne. Mønstret matcher stadig og udleder en tom Head eller Tail.

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

Sammenføjning igen

Den omvendte operation af opdeling er sammenføjning: Gå gennem en tupel af strenge, og sammenkæd dem med en separator ved hjælp af en template literal. Det passer naturligt sammen med opdeling.

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'

Fjernelse af blanktegn

Strengværktøjer kan sammensættes. En Trim-type fjerner indledende og afsluttende mellemrum ved gentagne gange at fjerne et mellemrum via template-inferens.

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'

Udskiftning af delstrenge

Udskiftning fungerer ved at opdele omkring målet og sammenføje igen med erstatningen, alt sammen via template-inferens og rekursion.

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'

Hvorfor opdeling er vigtig

Opdeling er grundlaget for struktureret parsing. Ruter opdeles ved "/", forespørgselsstrenge ved "&", og CSV-rækker ved ",". Med Split omdanner du en flad strengtype til en tupel, som du kan behandle element for element.

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

Pas på dybden

Rekursion på strengtyper er begrænset af kompilatorens dybdegrænse. Meget lange strenge eller mange separatorer kan overskride den. For typiske inputdata som stier og små formater fungerer det problemfrit.

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

Hurtig kontrol

Test din forståelse af strengopdeling på typeniveau.

Besvar den i den interaktive lektion

Opsummering

Du har opdelt strenge udelukkende i typer.

Template literal-typer plus infer matcher og indfanger dele af strenge.
SplitOnce opdeler ved den første separator; rekursion giver en komplet Split.
Join, Trim og ReplaceAll kan sammensættes ud fra de samme værktøjer.

Næste emne: udtrækning af strukturerede data fra strengtyper.

Gratis at komme i gang

Lær TypeScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 101
Lektioner: 352

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “String-opdeling på typeniveau” gratis?

Ja — hele teksten til “String-opdeling på typeniveau” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af TypeScript Academy-kurset, skal du opgradere til CoddyKit PRO. TypeScript Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “String-opdeling på typeniveau”?

Opdel strenge i tupler i typesystemet Du øver dig i TypeScript Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på TypeScript Academy?

Der kræves ingen tidligere erfaring. TypeScript Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “String-opdeling på typeniveau”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne TypeScript Academy-lektion?

Ja. Alle TypeScript Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til TypeScript Academy