TypeScript Academy · Pelajaran

Konsep Kombinator Parser

Susun parser kecil menjadi parser yang lebih besar.

Konsep Kombinator Parser adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar TypeScript Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus TypeScript Academy mencakup 4 pelajaran total.

Apa Itu Pengurai

Sebuah pengurai membaca masukan, biasanya berupa string, lalu menghasilkan keluaran terstruktur atau gagal. Kita memulai dari tingkat nilai untuk membangun intuisi sebelum memindahkan gagasan yang sama ke dalam sistem tipe.

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

Pengurai Kecil

Pengurai paling sederhana mencocokkan awalan literal. Jika masukan diawali teks yang diharapkan, pengurai berhasil dan mengembalikan teks yang tersisa; jika tidak, pengurai mengembalikan 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"));

Kombinator

Sebuah kombinator mengambil pengurai-pengurai kecil dan membangun pengurai yang lebih besar. Gaya komposisional inilah yang membuat pendekatan ini disebut kombinator pengurai: Anda menyusun pengurai kompleks dari bagian-bagian sederhana yang dapat digunakan kembali.

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

Pengurutan

Kombinator urutan menjalankan satu pengurai, lalu pengurai lain pada sisa masukan, dan memasangkan hasilnya. Keduanya harus berhasil agar urutan tersebut berhasil.

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

Menggunakan Urutan

Gabungkan dua nilai literal untuk mengurainya secara berurutan. Hasilnya memuat kedua bagian yang cocok dan masukan yang tersisa.

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

Pilihan

Kombinator pilihan mencoba pengurai pertama; jika gagal, pengurai kedua akan dicoba. Ini menyatakan alternatif, seperti "sebuah digit atau sebuah huruf".

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

Pengulangan

Kombinator many menerapkan pengurai berulang kali hingga gagal, lalu mengumpulkan semua hasilnya. Ini dapat mengurai daftar, rangkaian digit, atau spasi putih.

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

Memetakan Hasil

Kombinator map mengubah hasil pengurai tanpa mengubah bagian yang dikonsumsinya, misalnya mengubah karakter digit yang cocok menjadi angka.

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

Membangun Bertahap

Dari beberapa kombinator ini (literal, seq, alt, many, map), Anda dapat mengurai tata bahasa nyata: angka, pengenal, bahkan bahasa ekspresi kecil. Setiap lapisan menyusun lapisan di bawahnya.

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

Dari Nilai ke Tipe

Wawasan pentingnya: struktur komposisional yang sama juga berlaku pada tingkat tipe. Di sana, "masukan" adalah tipe literal string dan pengurai berupa tipe kondisional yang menggunakan inferensi literal templat. Selanjutnya, kita akan beralih ke sana.

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

Mengapa Penguraian Tingkat Tipe

Pengurai tingkat tipe memungkinkan kompiler memahami struktur literal string: jalur rute, string format, dan kunci query. Intuisi tentang kombinator yang Anda bangun di sini dapat diterapkan langsung pada teknik tingkat tipe di bagian lain kursus ini.

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

Uji Cepat

Uji pemahaman Anda tentang kombinator pengurai.

Rangkuman

Anda telah membangun intuisi tentang penguraian pada tingkat nilai.

Pengurai mengonsumsi masukan dan mengembalikan nilai beserta sisa masukan, atau gagal.
Kombinator (seq, alt, many, map) menyusun pengurai kecil menjadi pengurai besar.
Struktur yang sama juga berlaku pada tingkat tipe.

Berikutnya: memisahkan string dalam sistem tipe.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Konsep Kombinator Parser” gratis?

Ya — teks lengkap “Konsep Kombinator Parser” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus TypeScript Academy, upgrade ke CoddyKit PRO. Kursus TypeScript Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Konsep Kombinator Parser”?

Susun parser kecil menjadi parser yang lebih besar. Kamu berlatih TypeScript Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai TypeScript Academy?

Tidak diperlukan pengalaman sebelumnya. TypeScript Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Konsep Kombinator Parser” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran TypeScript Academy ini?

Ya. Setiap pelajaran TypeScript Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke TypeScript Academy