TypeScript Academy · Lektion

Begrepp inom parserkombinatorer

Kombinera små parsers till större.

Lektion 1 av 413 steg

Begrepp inom parserkombinatorer är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Vad är en parser

En parser läser indata (vanligtvis en sträng) och producerar strukturerad utdata eller misslyckas. Vi börjar på värdenivå för att bygga en intuition innan vi flyttar samma idéer till typsystemet.

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

En liten parser

Den enklaste parsern matchar ett bokstavligt prefix. Om indata börjar med den förväntade texten lyckas den och returnerar den återstående strängen; annars returnerar den 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"));

Kombinatorer

En kombinator tar små parsers och bygger större parsers. Denna kompositionella stil är anledningen till att metoden kallas parserkombinatorer: komplexa parsers sätts samman av enkla, återanvändbara delar.

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

Sekvensering

En sekvenskombinator kör en parser och sedan en annan på den återstående indata, och parar ihop deras resultat. Båda måste lyckas för att sekvensen ska lyckas.

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

Använda sekvens

Kombinera två literaler för att parsa dem i ordning. Resultatet innehåller båda de matchade delarna samt återstående indata.

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

Val

En valkombinator provar den första parsern och provar den andra om den misslyckas. Detta uttrycker alternativ, som "en siffra eller en bokstav".

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

Upprepning

En many-kombinator tillämpar en parser upprepade gånger tills den misslyckas och samlar alla resultat. Detta kan parsa listor, siffersekvenser eller blanksteg.

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

Mappa resultat

En map-kombinator omvandlar ett parserresultat utan att ändra vad parsern förbrukar, till exempel genom att omvandla matchade siffertecken till ett tal.

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

Bygga vidare

Med dessa få kombinatorer (literal, seq, alt, many, map) går det att parsa riktiga grammatiker: tal, identifierare och till och med små uttrycksspråk. Varje lager bygger vidare på lagret under det.

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

Från värden till typer

Den avgörande insikten är att samma komponerbara struktur fungerar på typenivå. Där är "indatan" en strängliteraltyp och parser är villkorstyper som använder inferens med mallitteraler. Nästa steg är att flytta dit.

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

Varför parsning på typenivå

Parser på typenivå låter kompilatorn förstå strukturen hos strängliteraler: route-sökvägar, formatsträngar och frågenycklar. Intuitionen kring kombinatorer som Ni har byggt upp här överförs direkt till teknikerna på typenivå i resten av kursen.

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

Snabbtest

Kontrollera Er förståelse av parserkombinatorer.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har byggt upp en intuition för parser på värdenivå.

En parser förbrukar indata och returnerar ett värde tillsammans med återstående indata, eller misslyckas.
Kombinatorer (seq, alt, many, map) kombinerar små parser till större.
Samma struktur gäller på typenivå.

Nästa steg: dela strängar i typsystemet.

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 101
Lektioner: 352

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Begrepp inom parserkombinatorer” gratis?

Ja – hela texten till ”Begrepp inom parserkombinatorer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Begrepp inom parserkombinatorer”?

Kombinera små parsers till större. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?

Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Begrepp inom parserkombinatorer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?

Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till TypeScript Academy