TypeScript Academy · Lektion

String-Aufteilung auf Typebene

Teilen Sie Strings innerhalb des Typsystems in Tupel auf.

String-Aufteilung auf Typebene ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Template-Literal-Typen

Das Typsystem kann mithilfe von Template-Literal-Typen in Kombination mit infer Muster in Stringliteral-Typen erkennen. Dies ist das zentrale Werkzeug für das Parsen von Zeichenketten auf Typebene.

Notation: In echtem TypeScript werden Template-Literal-Typen mit durch Backticks begrenzten Zeichenketten geschrieben, die Dollar-Brace-Platzhalter enthalten. In diesen Ausschnitten zeigen wir dieses Muster als Tpl<...> und listen die einzelnen Teile der Reihe nach auf. Eine Backtick-Vorlage, die zuerst dem Literalpräfix und anschließend Rest entspricht, erscheint beispielsweise 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

Ein Suffix ableiten

Platzieren Sie infer innerhalb der Vorlage, um einen Teil der Zeichenkette zu erfassen. Hier erfassen wir alles nach einem führenden "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'

An einem Trennzeichen aufteilen

Um eine Zeichenkette am ersten Vorkommen eines Trennzeichens aufzuteilen, passen Sie das Muster „Kopf, Trennzeichen, Ende“ an und inferieren beide Seiten. Das erste Vorkommen gewinnt, da die Inferenz für den Kopf von links aus gierig erfolgt.

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

Rekursives Aufteilen

Um eine Zeichenkette in alle Teile aufzuteilen, wenden Sie die Rekursion auf das Ende an. Sammeln Sie jeden Kopf in einem Tupel, bis kein Trennzeichen mehr vorhanden ist.

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

Die Rekursion nachvollziehen

Nachverfolgung von Split<"a.b.c", ".">:

Kopf „a“, Ende „b.c“ -> ["a", ...Split<"b.c">]
Kopf „b“, Ende „c“ -> ["b", ...Split<"c">]
„c“ enthält keinen „.“, Basisfall -> ["c"]

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

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

Leere Segmente behandeln

Beim Aufteilen können leere Zeichenketten entstehen, wenn Trennzeichen direkt nebeneinander oder am Anfang beziehungsweise Ende stehen. Das Muster passt weiterhin und inferiert einen leeren Head oder Tail.

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

Wieder zusammenfügen

Das Gegenstück zum Aufteilen ist das Zusammenfügen: Durchlaufen Sie ein Tupel aus Zeichenketten und verketten Sie diese mithilfe eines Template-Literals mit einem Trennzeichen. Das ergänzt sich auf natürliche Weise mit dem Aufteilen.

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'

Leerraum entfernen

String-Hilfsfunktionen lassen sich kombinieren. Ein Trim-Typ entfernt führende und nachfolgende Leerzeichen, indem er mithilfe von Template-Inferenz wiederholt ein Leerzeichen entfernt.

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'

Teilstrings ersetzen

Beim Ersetzen wird die Zeichenkette mithilfe von Template-Inferenz und Rekursion um das Ziel herum aufgeteilt und anschließend mit dem Ersatztext wieder zusammengefügt.

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'

Warum Aufteilen wichtig ist

Das Aufteilen bildet die Grundlage für strukturiertes Parsen. Routen werden an "/", Query-Strings an "&" und CSV-Zeilen an "," aufgeteilt. Mit Split wandeln Sie einen flachen Stringtyp in ein Tupel um, dessen Elemente Sie einzeln verarbeiten können.

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

Achtung bei der Rekursionstiefe

Die Rekursion von Zeichenketten auf Typebene ist durch das Tiefenlimit des Compilers begrenzt. Sehr lange Zeichenketten oder viele Trennzeichen können dieses Limit überschreiten. Für typische Eingaben wie Pfade und kleine Formate funktioniert sie problemlos.

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

Wissenscheck

Testen Sie Ihr Verständnis für das Aufteilen von Zeichenketten auf Typebene.

Zusammenfassung

Sie haben Zeichenketten vollständig in Typen aufgeteilt.

Template-Literal-Typen und infer erkennen und erfassen Teile von Zeichenketten.
SplitOnce teilt am ersten Trennzeichen auf; durch Rekursion entsteht ein vollständiges Split.
Join, Trim und ReplaceAll lassen sich aus denselben Werkzeugen zusammensetzen.

Als Nächstes: Strukturierte Daten aus Stringtypen extrahieren.

Häufig gestellte Fragen

Ist die Lektion „String-Aufteilung auf Typebene“ kostenlos?

Ja — der vollständige Text von „String-Aufteilung auf Typebene“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „String-Aufteilung auf Typebene“?

Teilen Sie Strings innerhalb des Typsystems in Tupel auf. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „String-Aufteilung auf Typebene“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu TypeScript Academy