TypeScript Academy · Les

Strings splitsen op typeniveau

Splits strings binnen het typesysteem op in tuples

Les 2 van 413 stappen

Strings splitsen op typeniveau is een gratis TypeScript Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 4 lessen.

Template-literaltypen

Het typesysteem kan patronen in letterlijke tekenreekstypen herkennen met template-literaltypen in combinatie met infer. Dit is het belangrijkste hulpmiddel voor het parsen van tekenreeksen op typeniveau.

Notatie: in echte TypeScript schrijft je template-literaltypen met door backticks begrensde tekenreeksen met dollar-accoladeplaatsen. In deze fragmenten geven we dat patroon weer als Tpl<...>, waarbij elk onderdeel in volgorde wordt opgesomd; zo verschijnt een backticksjabloon dat eerst het letterlijke voorvoegsel en daarna Rest matcht als 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

Een achtervoegsel afleiden

Plaats infer in het sjabloon om een deel van de tekenreeks vast te leggen. Hier leggen we alles vast na een beginnende "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'

Splitsen op een scheidingsteken

Als je een tekenreeks bij het eerste voorkomen van een scheidingsteken wilt splitsen, match je het patroon "kop, scheidingsteken, staart" en leid je beide kanten af. De eerste match wint, omdat de inferentie voor de kop vanaf links hebberig is.

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

Recursief splitsen

Als je in alle delen wilt splitsen, pas je recursie toe op de staart. Verzamel elke kop in een tupel totdat er geen scheidingsteken meer over is.

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

De recursie volgen

Volg Split<"a.b.c", ".">:

Head "a", Tail "b.c" -> ["a", ...Split<"b.c">]
Head "b", Tail "c" -> ["b", ...Split<"c">]
"c" heeft geen ".", basiscasus -> ["c"]

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

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

Lege segmenten verwerken

Splitsen kan lege tekenreeksen opleveren wanneer scheidingstekens naast elkaar staan of aan de randen voorkomen. Het patroon matcht nog steeds en leidt een lege Head of Tail af.

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

Weer samenvoegen

Het omgekeerde van splitsen is samenvoegen: doorloop een tupel met tekenreeksen en voeg ze met een scheidingsteken samen via een template literal. Dit past natuurlijk bij splitsen.

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'

Witruimte verwijderen

Tekenreeksfuncties kun je combineren. Een type Trim verwijdert spaties aan het begin en einde door herhaaldelijk een spatie te verwijderen via template-inferentie.

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'

Subtekenreeksen vervangen

Replace werkt door rond het doel te splitsen en opnieuw samen te voegen met de vervanging, volledig via template-inferentie en recursie.

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'

Waarom splitsen belangrijk is

Splitsen is de basis van gestructureerd parsen. Routes worden gesplitst op "/", querytekenreeksen op "&" en CSV-rijen op ",". Met Split zet je een vlak tekenreekstype om in een tupel dat je element voor element kunt verwerken.

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

Let op de diepte

Recursie van tekenreeksen op typeniveau wordt begrensd door de dieptelimiet van de compiler. Zeer lange tekenreeksen of veel scheidingstekens kunnen die limiet overschrijden. Voor gebruikelijke invoer, zoals paden en kleine indelingen, werkt dit soepel.

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

Korte controle

Toets je begrip van het splitsen van tekenreeksen op typeniveau.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt tekenreeksen volledig in typen gesplitst.

Template-literaltypen plus infer matchen en leggen delen van tekenreeksen vast.
SplitOnce splitst bij het eerste scheidingsteken; recursie levert een volledige Split op.
Join, Trim en ReplaceAll worden met dezelfde hulpmiddelen opgebouwd.

Volgende stap: gestructureerde gegevens uit tekenreekstypen halen.

Gratis beginnen

Leer TypeScript met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 101
Lessen: 352

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Strings splitsen op typeniveau” gratis?

Ja — de volledige tekst van “Strings splitsen op typeniveau” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 4 lessen.

Wat leer ik in “Strings splitsen op typeniveau”?

Splits strings binnen het typesysteem op in tuples Je oefent met TypeScript Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met TypeScript Academy te beginnen?

Ervaring vooraf is niet nodig. TypeScript Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Strings splitsen op typeniveau”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over TypeScript Academy?

Ja. Elke les over TypeScript Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar TypeScript Academy