Bun adalah runtime JavaScript yang dirancang untuk menjalankan kode JavaScript dan TypeScript dengan cepat, sekaligus menyediakan sejumlah tooling bawaan seperti package manager dan test runner. Untuk pemula yang baru mencoba Bun, langkah pertama yang paling berguna adalah memahami cara membuat file JavaScript sederhana, menjalankannya dari terminal, dan membaca argumen command line.

Pada artikel ini, kita akan fokus pada hal-hal praktis: struktur file yang dibutuhkan, perintah dasar bun untuk menjalankan script, contoh kode yang realistis tetapi tetap sederhana, serta beberapa perbedaan pengalaman penggunaan dibanding runtime lain. Tujuannya bukan membahas seluruh ekosistem Bun, melainkan membantu Anda menjalankan file JavaScript pertama dengan cara yang benar dan mudah dipahami.

Persiapan: memastikan Bun sudah terpasang

Sebelum membuat file JavaScript, pastikan perintah bun tersedia di terminal. Anda bisa memeriksanya dengan:

bun --version

Jika perintah tersebut menampilkan versi Bun, berarti instalasi sudah berhasil. Jika belum, Anda perlu memasang Bun terlebih dahulu sesuai sistem operasi yang digunakan. Karena fokus artikel ini adalah menjalankan file JavaScript pertama, kita tidak akan membahas detail instalasi secara panjang.

Catatan: Jika Anda sebelumnya terbiasa memakai Node.js, anggap Bun sebagai runtime lain untuk menjalankan JavaScript. Konsep dasar file script, terminal, dan argumen command line tetap mirip, sehingga proses belajarnya relatif mudah.

Struktur file paling sederhana

Untuk contoh pertama, kita tidak membutuhkan project yang kompleks. Cukup buat sebuah folder kerja, lalu simpan satu file JavaScript di dalamnya.

belajar-bun/
└── hello.js

Isi file hello.js bisa dimulai dari contoh paling dasar:

console.log("Halo dari Bun!");

Baris tersebut menggunakan console.log() untuk mencetak teks ke terminal. Ini adalah cara paling umum untuk memverifikasi bahwa file JavaScript berhasil dijalankan.

Setelah file tersimpan, masuk ke folder tersebut melalui terminal, lalu jalankan:

bun hello.js

Jika semuanya benar, terminal akan menampilkan:

Halo dari Bun!

Di titik ini, Anda sudah berhasil menjalankan file JavaScript pertama dengan Bun.

Memahami apa yang terjadi saat script dijalankan

Saat Anda menjalankan bun hello.js, Bun akan membaca file hello.js, memproses kode JavaScript di dalamnya, lalu mengeksekusinya. Karena script kita hanya berisi satu pemanggilan console.log(), hasilnya langsung muncul di terminal.

Konsep ini terdengar sederhana, tetapi penting untuk dipahami karena hampir semua script command line dibangun di atas pola yang sama:

  • terminal memanggil runtime, yaitu bun,
  • runtime membaca file script,
  • script dijalankan baris demi baris,
  • output muncul di terminal atau proses lain.

Memahami alur ini akan memudahkan Anda ketika nanti script menjadi lebih kompleks, misalnya membaca file, memanggil API, atau memproses input pengguna.

Membuat contoh yang sedikit lebih berguna

Mencetak lebih dari satu informasi

Contoh berikut masih sederhana, tetapi sudah lebih realistis karena menampilkan beberapa informasi sekaligus:

const appName = "Belajar Bun";
const message = "Script berhasil dijalankan.";

console.log(`Aplikasi: ${appName}`);
console.log(message);
console.log("Selamat mencoba JavaScript dengan Bun.");

Jalankan kembali dengan:

bun hello.js

Menggunakan variabel seperti ini adalah kebiasaan yang baik, bahkan pada script kecil, karena kode menjadi lebih mudah dibaca dan diubah.

Membaca argumen command line dasar

Salah satu kegunaan paling umum script terminal adalah menerima input dari command line. Misalnya, Anda ingin menjalankan script dengan nama tertentu agar output menjadi dinamis.

Buat file baru bernama greet.js:

const args = Bun.argv;
const name = args[2] || "teman";

console.log(`Halo, ${name}!`);
console.log("Script ini dijalankan dengan Bun.");

Lalu jalankan:

bun greet.js Andi

Output:

Halo, Andi!
Script ini dijalankan dengan Bun.

Jika Anda menjalankan tanpa argumen:

bun greet.js

Maka output-nya:

Halo, teman!
Script ini dijalankan dengan Bun.

Pada contoh ini, Bun.argv berisi daftar argumen command line. Elemen ketiga, yaitu args[2], biasanya adalah argumen pertama yang Anda berikan setelah nama file script. Nilai default "teman" dipakai jika pengguna tidak memberikan argumen apa pun.

Kenapa menggunakan nilai default? Karena script command line sering dijalankan dengan input yang tidak lengkap. Dengan memberi fallback, script tetap berjalan dan lebih ramah terhadap kesalahan penggunaan.

Menjelaskan struktur argumen dengan lebih jelas

Saat baru belajar command line, banyak orang bingung kenapa argumen pertama justru ada di indeks tertentu. Untuk membantu memahami, Anda bisa membuat file debug sederhana:

console.log(Bun.argv);

Lalu jalankan:

bun greet.js Andi developer

Struktur isi array dapat bervariasi tergantung konteks eksekusi, tetapi yang penting untuk tutorial dasar adalah mengetahui bahwa argumen yang Anda tambahkan setelah nama file bisa diakses dari daftar argumen tersebut. Dalam praktik sederhana, Anda sering mengambil argumen pertama, kedua, dan seterusnya untuk mengubah perilaku script.

Misalnya, Anda bisa memperluas contoh menjadi:

const args = Bun.argv;
const name = args[2] || "teman";
const role = args[3] || "pengguna";

console.log(`Halo, ${name}!`);
console.log(`Peran Anda: ${role}`);

Eksekusi:

bun greet.js Andi developer

Output:

Halo, Andi!
Peran Anda: developer

Pola seperti ini sering dipakai untuk utility internal, script otomatisasi kecil, atau tooling lokal di project.

Perintah dasar Bun untuk menjalankan script

Dalam penggunaan sehari-hari, perintah paling penting yang perlu diingat adalah:

bun nama-file.js

Contohnya:

bun hello.js
bun greet.js Andi

Secara praktis, Bun mencoba memberikan pengalaman yang sederhana: Anda menunjuk file JavaScript, lalu runtime mengeksekusinya. Untuk script kecil, ini terasa langsung dan minim konfigurasi.

Jika nantinya Anda bekerja dengan project yang lebih besar, Anda mungkin akan menambahkan file seperti package.json, script command, atau modul lain. Namun untuk memulai, Bun tidak memaksa struktur project yang rumit hanya untuk menjalankan satu file JavaScript.

Perbedaan pengalaman dibanding runtime lain secara singkat

Jika Anda pernah memakai Node.js, pengalaman dasar menggunakan Bun akan terasa familiar. Keduanya dijalankan dari terminal dan sama-sama mengeksekusi file JavaScript. Perintah dasar di Node biasanya:

node hello.js

Sedangkan di Bun:

bun hello.js

Perbedaan utamanya dalam konteks artikel ini bukan pada sintaks JavaScript, melainkan pada pengalaman runtime dan tooling:

  • Bun cenderung menawarkan banyak tooling bawaan dalam satu paket.
  • Node.js memiliki ekosistem yang sangat matang dan sering menjadi pilihan default di banyak project produksi.
  • Bun terasa praktis untuk eksperimen cepat karena satu alat dapat dipakai untuk menjalankan script, mengelola dependency, dan tugas lain.

Namun, ada trade-off yang perlu dipahami:

  • Tidak semua package atau perilaku environment selalu identik dengan Node.js.
  • Jika Anda bekerja pada project lama yang sangat bergantung pada perilaku spesifik Node, pengujian kompatibilitas tetap diperlukan.
  • Untuk script sederhana seperti contoh di artikel ini, perbedaannya biasanya kecil dan tidak menjadi masalah.

Jadi, kapan memilih Bun? Untuk belajar, eksperimen, script utilitas kecil, atau mencoba workflow modern, Bun sangat menarik. Untuk project yang memiliki kebutuhan kompatibilitas luas dengan tooling lama, Anda tetap perlu mengevaluasi dengan hati-hati.

Kesalahan umum dan tips debugging

File tidak ditemukan

Kesalahan paling umum adalah menjalankan file dari folder yang salah.

bun hello.js

Jika terminal mengatakan file tidak ditemukan, cek dua hal:

  • apakah Anda sedang berada di direktori yang benar,
  • apakah nama file persis sama, termasuk huruf besar-kecil jika sistem operasi Anda sensitif terhadapnya.

Salah membaca argumen

Jika output nama tidak sesuai, sering kali penyebabnya adalah indeks argumen yang salah. Solusi termudah adalah mencetak seluruh isi argumen:

console.log(Bun.argv);

Dari situ Anda bisa melihat posisi argumen yang benar.

Lupa menyimpan file

Terdengar sepele, tetapi ini sering terjadi. Anda mengubah isi file, menjalankan ulang script, lalu bingung karena output tidak berubah. Pastikan file sudah tersimpan sebelum dieksekusi kembali.

Gunakan output debug sederhana

Untuk script kecil, debugging tidak selalu memerlukan alat kompleks. Menambahkan console.log() sementara di titik penting sering kali sudah cukup untuk mengetahui nilai variabel dan alur eksekusi.

Praktik baik untuk script kecil

Meskipun script kita sangat sederhana, ada beberapa kebiasaan yang layak diterapkan sejak awal:

  • Gunakan nama file yang jelas, misalnya greet.js lebih informatif daripada test1.js.
  • Beri nilai default untuk input agar script tidak mudah gagal.
  • Jaga output tetap ringkas supaya mudah dibaca di terminal.
  • Pisahkan contoh berdasarkan tujuan, misalnya satu file untuk hello world dan satu file untuk argumen.

Kebiasaan kecil ini akan sangat membantu saat Anda mulai membuat script otomatisasi yang benar-benar dipakai dalam workflow harian.

Penutup dan ide eksperimen lanjutan

Menjalankan file JavaScript pertama dengan Bun pada dasarnya sangat sederhana: buat file .js, isi dengan kode JavaScript, lalu jalankan menggunakan perintah bun nama-file.js. Dari situ, Anda bisa mulai membangun script yang lebih berguna, misalnya menerima argumen dari command line dan menghasilkan output dinamis.

Dalam artikel ini, kita sudah melihat tiga hal penting: struktur file minimal, cara mencetak teks ke terminal, dan cara membaca argumen command line secara dasar. Ini adalah fondasi yang cukup untuk mulai bereksperimen dengan Bun sebagai runtime JavaScript sehari-hari.

Untuk latihan kecil, coba beberapa eksperimen berikut:

  1. Buat script yang menerima dua argumen: nama dan kota, lalu tampilkan kalimat seperti Halo, Andi dari Bandung!.
  2. Tambahkan pengecekan jika argumen belum lengkap, lalu tampilkan pesan penggunaan script.
  3. Buat file sum.js yang menerima dua angka dari command line dan mencetak hasil penjumlahannya.
  4. Coba jalankan script yang sama dengan Bun dan runtime lain yang Anda kenal, lalu bandingkan pengalaman dasarnya.

Dengan eksperimen sederhana seperti ini, Anda tidak hanya belajar sintaks JavaScript, tetapi juga mulai memahami bagaimana script command line bekerja dalam konteks runtime modern seperti Bun.