TypeScript Academy · Leçon

Concepts des combinateurs d’analyse

Composer de petits analyseurs pour en former de plus grands.

Concepts des combinateurs d’analyse est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Qu'est-ce qu'un analyseur syntaxique

Un analyseur syntaxique lit une entrée (généralement une chaîne) et produit une sortie structurée, ou échoue. Nous commençons au niveau des valeurs pour acquérir une intuition avant de transposer les mêmes idées dans le système de types.

type Parser<T> = (input: string) => { value: T; rest: string } | null;
// Consumes part of the input, returns a value and the leftover

Un petit analyseur syntaxique

L'analyseur syntaxique le plus simple reconnaît un préfixe littéral. Si l'entrée commence par le texte attendu, il réussit et renvoie la chaîne restante ; sinon, il renvoie null.

function literal(prefix: string): Parser<string> {
  return input =>
    input.startsWith(prefix)
      ? { value: prefix, rest: input.slice(prefix.length) }
      : null;
}
console.log(literal("ab")("abc"));

Les combinateurs

Un combinateur prend de petits analyseurs syntaxiques et en construit de plus grands. Ce style fondé sur la composition explique pourquoi cette approche est appelée combinateurs d'analyse syntaxique : vous assemblez des analyseurs complexes à partir d'éléments simples et réutilisables.

// Small parsers: digit, letter, literal
// Combinators: sequence, choice, many
// Compose them into: number, identifier, expression

L'enchaînement

Un combinateur de séquence exécute un analyseur syntaxique, puis un autre sur le reste, en associant leurs résultats. Les deux doivent réussir pour que la séquence réussisse.

function seq<A, B>(pa: Parser<A>, pb: Parser<B>): Parser<[A, B]> {
  return input => {
    const ra = pa(input);
    if (!ra) return null;
    const rb = pb(ra.rest);
    if (!rb) return null;
    return { value: [ra.value, rb.value], rest: rb.rest };
  };
}

Utiliser une séquence

Combinez deux littéraux pour les analyser dans l’ordre. Le résultat contient les deux éléments correspondants ainsi que l’entrée restante.

const ab = seq(literal("a"), literal("b"));
const r = ab("abc");
console.log(r); // { value: ["a","b"], rest: "c" }

Choix

Un combinateur de choix essaie le premier analyseur ; s’il échoue, il essaie le second. Cela exprime des alternatives, comme « un chiffre ou une lettre ».

function alt<T>(p1: Parser<T>, p2: Parser<T>): Parser<T> {
  return input => p1(input) ?? p2(input);
}

Répétition

Un combinateur many applique un analyseur de façon répétée jusqu’à son échec, en rassemblant tous les résultats. Cela permet d’analyser des listes, des suites de digits ou des espaces.

function many<T>(p: Parser<T>): Parser<T[]> {
  return input => {
    const out: T[] = [];
    let rest = input;
    let r = p(rest);
    while (r) { out.push(r.value); rest = r.rest; r = p(rest); }
    return { value: out, rest };
  };
}

Transformer les résultats

Un combinateur map transforme le résultat d’un analyseur sans modifier ce qu’il consomme, par exemple en transformant des caractères correspondant à des digits en nombre.

function map<A, B>(p: Parser<A>, f: (a: A) => B): Parser<B> {
  return input => {
    const r = p(input);
    return r ? { value: f(r.value), rest: r.rest } : null;
  };
}

Construction progressive

À partir de ces quelques combinateurs (littéral, seq, alt, many, map), vous pouvez analyser de vraies grammaires : des nombres, des identifiants et même de petits langages d’expressions. Chaque couche compose avec celle qui se trouve en dessous.

const digit = alt(literal("0"), literal("1")); // toy digit
const digits = many(digit);
console.log(digits("0110x"));

Des valeurs aux types

L’idée essentielle est que la même structure compositionnelle fonctionne au niveau des types. Là, l’« entrée » est un type littéral de chaîne et les analyseurs sont des types conditionnels qui utilisent l’inférence des littéraux de modèle. Nous allons maintenant passer à ce niveau.

// Value level: (input: string) => { value, rest } | null
// Type level:  conditional types over string literal types

Pourquoi analyser au niveau des types

Les analyseurs au niveau des types permettent au compilateur de comprendre la structure des littéraux de chaîne : chemins de routes, chaînes de format et clés de requête. L’intuition des combinateurs que vous avez développée ici s’applique directement aux techniques au niveau des types utilisées dans la suite de ce cours.

// Goal: parse "users/:id" into { id: string } at compile time

Vérification rapide

Testez votre compréhension des combinateurs d’analyseurs.

Récapitulatif

Vous avez développé une intuition des analyseurs au niveau des valeurs.

Un analyseur consomme une entrée et renvoie une valeur accompagnée de ce qu’il reste, ou échoue.
Les combinateurs (seq, alt, many, map) composent de petits analyseurs pour en former de grands.
La même structure s’applique au niveau des types.

Ensuite : découper des chaînes dans le système de types.

Questions Fréquemment Posées

La leçon « Concepts des combinateurs d’analyse » est-elle gratuite ?

Oui — le texte complet de « Concepts des combinateurs d’analyse » 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 « Concepts des combinateurs d’analyse » ?

Composer de petits analyseurs pour en former de plus grands. 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 1 sur 4.

Combien de temps prend la leçon « Concepts des combinateurs d’analyse » ?

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