TypeScript Academy · Leçon

Découpage de chaînes au niveau des types

Découper des chaînes en tuples au sein du système de types.

Découpage de chaînes au niveau des types est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Types littéraux de modèle

Le système de types peut faire correspondre des motifs avec des types littéraux de chaîne à l’aide des types littéraux de modèle combinés à infer. C’est l’outil central pour analyser des chaînes au niveau des types.

Notation : en TypeScript réel, les types littéraux de modèle s’écrivent avec des chaînes délimitées par des accents graves contenant des emplacements dollar-accolade. Dans ces extraits, nous représentons ce motif sous la forme Tpl<...>, en indiquant chaque partie dans l’ordre ; par exemple, un modèle avec accent grave correspondant au préfixe littéral puis à Rest apparaît sous la forme 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

Inférer un suffixe

Placez infer dans le modèle pour capturer une partie de la chaîne. Ici, nous capturons tout ce qui suit un "a" initial.

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'

Découper avec un séparateur

Pour découper une chaîne à la première occurrence d’un séparateur, faites correspondre le motif « tête, séparateur, queue » et inférez les deux côtés. La première correspondance est retenue, car l’inférence de la tête est gloutonne à partir de la gauche.

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

Découpage récursif

Pour obtenir toutes les parties, appliquez la récursion à la queue. Ajoutez chaque tête à un tuple jusqu’à ce qu’il ne reste plus de séparateur.

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

Parcourir la récursion

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

Tête « a », queue « b.c » -> [« a », ...Split<"b.c">]
Tête « b », queue « c » -> [« b », ...Split<"c">]
« c » ne contient aucun « . », cas de base -> [« c »]

Résultat : [« a », « b », « c »].

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

Gérer les segments vides

Le découpage peut produire des chaînes vides lorsque les séparateurs sont adjacents ou placés aux extrémités. Le motif correspond tout de même, en inférant une Head ou une Tail vide.

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

Reconstituer

L’opération inverse du découpage est la jointure : parcourez un tuple de chaînes et concaténez-les avec un séparateur à l’aide d’un littéral de modèle. Cette opération s’associe naturellement au découpage.

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'

Supprimer les espaces

Les utilitaires de chaîne se composent entre eux. Un type Trim supprime les espaces initiaux et finaux en retirant répétitivement un espace par inférence de modèle.

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'

Remplacer des sous-chaînes

Le remplacement fonctionne en découpant autour de la cible, puis en reconstituant la chaîne avec le remplacement, le tout grâce à l’inférence de modèle et à la récursion.

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'

Pourquoi le découpage est important

Le découpage est la base de l’analyse structurée. Les routes sont découpées sur "/", les chaînes de requête sur "&" et les lignes CSV sur ",". Avec Split, vous transformez un type de chaîne plate en tuple que vous pouvez traiter élément par élément.

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

Attention à la profondeur

La récursion de chaînes au niveau des types est limitée par la profondeur maximale du compilateur. Des chaînes très longues ou un grand nombre de séparateurs peuvent dépasser cette limite. Pour les entrées courantes (chemins et petits formats), elle fonctionne sans difficulté.

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

Vérification rapide

Testez votre compréhension du découpage de chaînes au niveau des types.

Récapitulatif

Vous avez découpé des chaînes entièrement dans les types.

Les types littéraux de modèle associés à infer font correspondre et capturent des parties de chaînes.
SplitOnce découpe à la première occurrence du séparateur ; la récursion produit un Split complet.
Join, Trim et ReplaceAll se composent à partir des mêmes outils.

Ensuite : extraire des données structurées à partir de types de chaînes.

Questions Fréquemment Posées

La leçon « Découpage de chaînes au niveau des types » est-elle gratuite ?

Oui — le texte complet de « Découpage de chaînes au niveau des types » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Découpage de chaînes au niveau des types » ?

Découper des chaînes en tuples au sein du système de types. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Découpage de chaînes au niveau des types » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Concepts des combinateurs d’analyse
Découpage de chaînes au niveau des types
Analyser avec les littéraux de modèles
Mini-analyseur de routes au niveau des types

← Retour à TypeScript Academy