Logo Universitas Teknokrat Indonesia

Nearley: Dari Teori ke Praktik, Panduan Membangun Parser Kustom yang Kuat dan Cepat

Kategori: Teknologi
Gambar untuk Nearley: Dari Teori ke Praktik, Panduan Membangun Parser Kustom yang Kuat dan Cepat

Dalam dunia pengembangan perangkat lunak, tantangan untuk mengubah teks yang tidak terstruktur menjadi data yang dapat diproses adalah hal yang umum. Dari file konfigurasi yang rumit hingga bahasa kueri internal, kita sering kali membutuhkan parser—sebuah alat yang dapat memahami struktur tata bahasa dari teks. Sementara banyak parser generator bersifat kaku dan sulit digunakan, Nearley menawarkan pendekatan yang berbeda. Artikel ini akan membawa Anda dari konsep teoretis ke implementasi praktis, menunjukkan bagaimana Nearley memungkinkan pengembang untuk membangun parser kustom yang kuat dan efisien dengan cara yang mudah.

Baca juga:Lebih dari Sekadar Mainan: Mengupas Teknologi Canggih di Balik Drone Parrot, Pesaing Serius DJI dari Eropa

Memahami Konsep Dasar: Grammar dan Parser Generator

Sebelum kita terjun ke dalam kode, penting untuk memahami dua konsep kunci:

  • Grammar: Ini adalah serangkaian aturan yang mendefinisikan struktur tata bahasa dari input yang kita harapkan. Misalnya, sebuah aturan sederhana bisa jadi "sebuah kalimat adalah subjek, diikuti oleh kata kerja, dan diakhiri dengan titik." Dalam konteks Nearley, grammar didefinisikan dalam sebuah file teks dengan format khusus.
  • Parser Generator: Ini adalah program yang mengambil file grammar dan secara otomatis menghasilkan kode parser. Dengan kata lain, Anda tidak perlu menulis kode parser yang rumit dari nol; Anda hanya perlu mendefinisikan aturannya, dan Nearley akan melakukan sisanya.

Pendekatan ini sangat efisien. Anda dapat fokus pada desain bahasa atau format data, sementara Nearley menangani kompleksitas algoritmik dari parsing.

Langkah 1: Menginstal Nearley

Pertama, pastikan Anda telah menginstal Node.js di sistem Anda. Nearley dapat diinstal dengan mudah melalui npm (Node Package Manager).

Bash

npm install -g nearley

Perintah di atas akan menginstal Nearley CLI secara global, yang memungkinkan Anda untuk menjalankan Nearley dari terminal di mana saja.

Langkah 2: Mendefinisikan Grammar Anda

Mari kita buat contoh sederhana: sebuah parser untuk mengevaluasi ekspresi matematika dasar seperti 1 + 2 * 3.

Buat sebuah file baru bernama math.ne. Ekstensi .ne adalah konvensi untuk file grammar Nearley.

Code snippet

@lexer moo

main -> expression

expression -> expression _ "+" _ term {%
    ([$1, , , , $5]) => $1 + $5
%}
          | expression _ "-" _ term {%
    ([$1, , , , $5]) => $1 - $5
%}
          | term

term -> term _ "*" _ factor {%
    ([$1, , , , $5]) => $1 * $5
%}
      | term _ "/" _ factor {%
    ([$1, , , , $5]) => $1 / $5
%}
      | factor

factor -> number
        | "(" _ expression _ ")" {%
    ([, , $3]) => $3
%}

number -> [0-9]:+ {%
    ([d]) => Number(d.join(""))
%}

_ -> ws:*
ws -> " " | "\t" | "\n"

Mari kita bedah kode di atas:

  • @lexer moo: Nearley sering kali digunakan bersama Moo, sebuah lexer (token generator) yang sangat cepat. Lexer bertugas memecah teks menjadi "token" (misalnya, angka, simbol +, tanda kurung).
  • main -> expression: Ini adalah "aturan awal" atau titik masuk utama. Kita mengatakan bahwa parser kita akan mencari sebuah expression (ekspresi).
  • expression -> ...: Aturan ini mendefinisikan apa itu ekspresi. Di sini, kita mendefinisikan bahwa ekspresi bisa berupa penjumlahan atau pengurangan dari sebuah term atau hanya sebuah term itu sendiri.
  • {% ... %}: Blok kode ini adalah postprocessor. Nearley menjalankan kode JavaScript di dalam blok ini setelah berhasil mengurai sebuah aturan. Dalam contoh ini, kita langsung melakukan operasi matematika ($1 + $5) untuk mengembalikan hasil perhitungan. Variabel $1, $2, dst. merepresentasikan hasil dari setiap bagian dari aturan yang diurai.
  • _ -> ws:*: Aturan ini mendefinisikan bahwa _ (underscore) adalah nol atau lebih karakter spasi putih (ws). Ini memungkinkan kita untuk mengabaikan spasi di antara token.
  • number -> [0-9]:+: Ini adalah sebuah regex (regular expression) sederhana yang mendefinisikan bahwa sebuah number adalah satu atau lebih digit angka.

Langkah 3: Menggunakan Nearley untuk Menggenerasi Parser

Setelah grammar Anda siap, saatnya untuk menghasilkan file parser. Jalankan perintah berikut di terminal:

Bash

nearleyc math.ne -o math.js

Perintah ini akan membaca file math.ne dan menghasilkan kode parser JavaScript di file math.js. File math.js ini adalah parser yang sebenarnya.

Langkah 4: Menggunakan Parser dalam Kode JavaScript

Sekarang kita dapat menggunakan parser yang baru saja kita buat untuk mengurai ekspresi. Buat file baru bernama test.js.

JavaScript

const nearley = require("nearley");
const grammar = require("./math.js");

const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));

try {
    const input = "1 + 2 * (3 + 4)";
    parser.feed(input);

    if (parser.results.length === 0) {
        console.log("Error: No parse result found.");
    } else {
        // Nearley returns an array of all possible parse results.
        // For non-ambiguous grammars, there's only one result.
        const result = parser.results[0];
        console.log(`Input: ${input}`);
        console.log(`Result: ${result}`);
    }
} catch (e) {
    console.error(`Error during parsing: ${e.message}`);
}

Jalankan skrip ini dengan Node.js:

Bash

node test.js

Output yang akan Anda dapatkan adalah:

Input: 1 + 2 * (3 + 4)
Result: 15

Ini menunjukkan bahwa parser Anda berhasil mengurai ekspresi, mengikuti urutan operasi standar (perkalian sebelum penjumlahan), dan bahkan menangani tanda kurung dengan benar.

Mengapa Pendekatan Ini Efektif?

Proses ini sangat kuat dan efisien karena:

  • Separasi Kekhawatiran (Separation of Concerns): Anda memisahkan definisi bahasa (.ne) dari logika aplikasi yang menggunakan bahasa tersebut (.js). Ini membuat kode lebih bersih dan lebih mudah dikelola.
  • Kecepatan Pengembangan: Perubahan pada sintaks bahasa dapat dilakukan dengan cepat di file .ne, tanpa perlu memodifikasi kode JavaScript yang besar.
  • Kekuatan Algoritma: Anda mendapatkan semua manfaat dari algoritma Earley yang canggih tanpa perlu memahami detail implementasinya. Anda hanya perlu mendefinisikan aturan Anda.

Baca juga: Mahasiswa Teknokrat Juara KTI dan Best Expodi PIMPI 2025 IPB University

Nearley sebagai Alat Penting bagi Pengembang

Dari teori parser yang kompleks hingga implementasi praktis yang mudah, Nearley menjembatani kesenjangan tersebut dengan sangat efektif. Dengan panduan ini, Anda kini memiliki pemahaman dasar dan contoh kerja untuk mulai membangun parser kustom Anda sendiri.

Baik Anda ingin membuat bahasa skrip untuk game Anda, mengurai file log yang unik, atau membangun kompiler untuk bahasa baru, Nearley adalah alat yang sangat berharga. Ia menawarkan kekuatan algoritma parser terbaik dengan kemudahan penggunaan yang luar biasa, memungkinkan Anda untuk fokus pada hal yang paling penting: membangun solusi yang kreatif dan inovatif. Dengan Nearley, Anda tidak lagi hanya seorang pengguna bahasa, tetapi seorang arsitek bahasa yang mampu membentuk dan mengendalikan cara komputer memproses informasi.

Penulis: Fiska Anggraini

Bagikan ke WhatsApp