TypeScript Academy · Lektion

Konzepte von Parser-Kombinatoren

Kombinieren Sie kleine Parser zu größeren Parsern.

Konzepte von Parser-Kombinatoren ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Was ist ein Parser

Ein Parser liest Eingaben (normalerweise einen String) und erzeugt eine strukturierte Ausgabe oder schlägt fehl. Wir beginnen auf Wertebene, um ein intuitives Verständnis zu entwickeln, bevor wir dieselben Ideen in das Typsystem übertragen.

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

Ein winziger Parser

Der einfachste Parser erkennt ein wörtliches Präfix. Beginnt die Eingabe mit dem erwarteten Text, ist der Parser erfolgreich und gibt den verbleibenden String zurück; andernfalls gibt er null zurück.

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

Kombinatoren

Ein Kombinator nimmt kleine Parser und erstellt daraus größere. Dieser kompositionale Ansatz erklärt, warum die Methode Parser-Kombinatoren genannt wird: Sie setzen komplexe Parser aus einfachen, wiederverwendbaren Bestandteilen zusammen.

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

Sequenzierung

Ein Sequenz-Kombinator führt einen Parser aus und anschließend einen weiteren auf der verbleibenden Eingabe, wobei er ihre Ergebnisse zu einem Paar zusammenfasst. Beide Parser müssen erfolgreich sein, damit die Sequenz erfolgreich ist.

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 };
  };
}

Sequenzen verwenden

Kombinieren Sie zwei Literale, um sie der Reihe nach zu parsen. Das Ergebnis enthält beide übereinstimmenden Teile und die verbleibende Eingabe.

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

Auswahl

Ein Auswahlkombinator versucht den ersten Parser. Wenn dieser fehlschlägt, wird der zweite versucht. Damit lassen sich Alternativen ausdrücken, etwa „eine Ziffer oder ein Buchstabe“.

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

Wiederholung

Ein many-Kombinator wendet einen Parser wiederholt an, bis dieser fehlschlägt, und sammelt alle Ergebnisse. Damit lassen sich Listen, Ziffernfolgen oder Leerraum parsen.

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 };
  };
}

Ergebnisse abbilden

Ein map-Kombinator transformiert das Parserergebnis, ohne die gelesene Eingabe zu verändern, etwa indem übereinstimmende Ziffernzeichen in eine Zahl umgewandelt werden.

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;
  };
}

Schrittweise aufbauen

Aus diesen wenigen Kombinatoren (literal, seq, alt, many, map) können Sie echte Grammatiken parsen: Zahlen, Bezeichner und sogar kleine Ausdruckssprachen. Jede Ebene setzt auf der darunterliegenden auf.

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

Von Werten zu Typen

Die entscheidende Erkenntnis: Dieselbe kompositionale Struktur funktioniert auch auf Typebene. Dort ist die „Eingabe“ ein Stringliteral-Typ, und Parser sind Conditional Types, die Template-Literal-Inferenz verwenden. Als Nächstes wechseln wir dorthin.

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

Warum Parsing auf Typebene

Parser auf Typebene ermöglichen es dem Compiler, die Struktur von Stringliteral-Typen zu verstehen: Routenpfade, Formatstrings und Query-Schlüssel. Die Kombinatorintuition, die Sie hier aufgebaut haben, lässt sich direkt auf die Type-Level-Techniken im restlichen Kurs übertragen.

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

Wissenscheck

Testen Sie Ihr Verständnis von Parserkombinatoren.

Zusammenfassung

Sie haben auf Wertebene ein Verständnis für Parser entwickelt.

Ein Parser verarbeitet Eingaben und gibt entweder einen Wert zusammen mit dem Rest zurück oder schlägt fehl.
Kombinatoren (seq, alt, many, map) setzen kleine Parser zu größeren zusammen.
Dieselbe Struktur gilt auch auf Typebene.

Als Nächstes: Zeichenketten im Typsystem aufteilen.

Häufig gestellte Fragen

Ist die Lektion „Konzepte von Parser-Kombinatoren“ kostenlos?

Ja — der vollständige Text von „Konzepte von Parser-Kombinatoren“ 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 „Konzepte von Parser-Kombinatoren“?

Kombinieren Sie kleine Parser zu größeren Parsern. 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 1 von 4.

Wie lange dauert die Lektion „Konzepte von Parser-Kombinatoren“?

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