Saat pertama kali belajar Rust, banyak orang langsung bertemu dengan potongan kode yang tampak singkat tetapi belum tentu langsung mudah dipahami. Padahal, sebelum masuk ke topik yang lebih jauh seperti ownership, struct, atau enum, hal paling penting adalah memahami susunan dasar program Rust. Dengan memahami bagian-bagian kecil ini, Anda akan lebih mudah membaca kode, menulis program sederhana, dan menghindari kesalahan dasar yang sering muncul.

Di artikel ini, kita akan membahas anatomi program Rust yang paling dasar: fungsi main, penggunaan let untuk variabel, println! untuk menampilkan teks, komentar, titik koma, kurung kurawal, dan alur eksekusi program. Penjelasannya dibuat ringan dan bertahap agar mudah diikuti oleh pemula total.

Program Rust Paling Sederhana

Berikut contoh program Rust yang sangat sederhana:

fn main() {
    // Menampilkan pesan ke layar
    let nama = "Rust";
    println!("Halo, {}!", nama);
}

Meskipun hanya terdiri dari beberapa baris, program ini sudah menunjukkan struktur dasar Rust yang penting. Mari kita pahami satu per satu.

Anatomi Dasar Program Rust

1. Fungsi main sebagai titik awal program

Di Rust, program yang bisa dijalankan biasanya dimulai dari fungsi bernama main.

fn main() {
    println!("Halo dunia!");
}

Bagian fn adalah singkatan dari function, yaitu cara Rust mendefinisikan fungsi. Jadi, fn main() berarti kita sedang membuat fungsi bernama main.

Kenapa main penting? Karena saat program dijalankan, Rust akan mencari fungsi ini sebagai titik awal eksekusi. Sederhananya, komputer mulai membaca dan menjalankan instruksi dari dalam main.

Catatan: Jika Anda menulis program Rust yang bisa dieksekusi tetapi tidak memiliki fungsi main, program tersebut tidak akan berjalan sebagaimana mestinya.

2. Peran tanda kurung biasa dan kurung kurawal

Pada baris fn main() {, ada dua jenis tanda kurung yang perlu diperhatikan:

  • () setelah main digunakan untuk menandai parameter fungsi. Pada contoh ini kosong, artinya fungsi main tidak menerima masukan langsung.
  • {} digunakan untuk membungkus isi fungsi, yaitu blok kode yang akan dijalankan.

Kurung kurawal sangat penting karena menentukan batas blok. Semua baris di dalam kurung kurawal milik fungsi tersebut.

fn main() {
    println!("Baris ini ada di dalam main");
}

// Baris di luar kurung kurawal bukan bagian dari fungsi main

Kalau kurung kurawal tidak seimbang, misalnya ada yang kurang tutup atau kurang buka, Rust akan memberikan pesan galat saat kompilasi. Ini sering terjadi pada pemula, jadi biasakan mengecek pasangan { dan } dengan teliti.

3. let untuk membuat variabel

Untuk menyimpan data, Rust menggunakan let.

let nama = "Rust";

Baris ini berarti kita membuat variabel bernama nama dan mengisinya dengan nilai "Rust".

Dalam banyak bahasa pemrograman, variabel adalah tempat menyimpan nilai agar bisa dipakai lagi nanti. Di Rust, let adalah cara standar untuk mendeklarasikan variabel.

Contoh lain:

let umur = 3;
let aktif = true;

Di sini:

  • umur menyimpan angka 3
  • aktif menyimpan nilai benar/salah, yaitu true

Rust cukup pintar untuk menebak tipe data dari nilai yang diberikan, jadi pemula tidak harus selalu menulis tipe secara manual. Ini membuat kode dasar lebih mudah dibaca.

Catatan penting: Variabel yang dibuat dengan let secara default tidak bisa diubah. Untuk tahap awal, cukup pahami bahwa let dipakai untuk menyimpan nilai. Nanti saat belajar lebih lanjut, Anda akan bertemu mut untuk variabel yang bisa diubah.

4. println! untuk menampilkan output

Jika Anda ingin menampilkan teks ke terminal atau konsol, gunakan println!.

println!("Halo dunia!");

Perintah ini akan mencetak teks Halo dunia! lalu pindah ke baris baru. Ini sangat sering dipakai saat belajar, mengecek hasil program, atau melakukan debugging sederhana.

Anda juga bisa menampilkan nilai variabel:

let nama = "Rust";
println!("Halo, {}!", nama);

Tanda {} adalah tempat untuk menyisipkan nilai. Nilai nama akan dimasukkan ke posisi tersebut, sehingga hasilnya menjadi:

Halo, Rust!

Ada satu hal yang sering membuat pemula bertanya: kenapa namanya println! memakai tanda seru? Dalam Rust, tanda seru menunjukkan bahwa itu adalah macro. Untuk tahap awal, Anda tidak perlu memikirkan detail dalamnya. Cukup pahami bahwa println! adalah cara yang benar untuk mencetak output ke layar.

5. Komentar untuk memberi penjelasan di kode

Komentar adalah teks yang ditulis di kode tetapi tidak dijalankan sebagai instruksi program. Komentar berguna untuk menjelaskan maksud kode, memberi catatan, atau mengingatkan sesuatu.

Rust mendukung komentar satu baris dengan //.

// Ini adalah komentar
let nama = "Rust";

Anda juga bisa menaruh komentar di atas baris kode:

// Menyimpan nama bahasa pemrograman
let nama = "Rust";

// Menampilkan salam
println!("Halo, {}!", nama);

Komentar yang baik membantu Anda dan orang lain memahami kode lebih cepat. Namun, jangan berlebihan. Jika kode sudah jelas, komentar tidak perlu mengulang hal yang sama dengan kata lain.

Contoh komentar yang berguna:

// Nilai ini dipakai untuk salam awal pengguna
let nama = "Rust";

Contoh komentar yang kurang berguna:

// Membuat variabel nama
let nama = "Rust";

Komentar kedua sebenarnya hanya mengulang isi kode tanpa menambah informasi.

6. Titik koma di akhir pernyataan

Di Rust, banyak baris instruksi diakhiri dengan titik koma ;.

let nama = "Rust";
println!("Halo, {}!", nama);

Untuk tahap dasar, anggap saja titik koma adalah penanda bahwa sebuah perintah sudah selesai. Jika Anda lupa menaruhnya di tempat yang seharusnya, Rust biasanya akan menampilkan error saat kompilasi.

Meski begitu, ada konteks tertentu di Rust di mana titik koma punya arti lebih dalam, misalnya terkait nilai yang dikembalikan dari blok atau fungsi. Untuk pemula, cukup pegang aturan praktis ini:

  • Setelah deklarasi variabel dengan let, gunakan titik koma.
  • Setelah pemanggilan println!, gunakan titik koma.
  • Jika compiler mengeluh, cek dulu apakah ada titik koma yang tertinggal atau justru berlebih.

Contoh Program dan Penjelasan Baris per Baris

Sekarang mari lihat contoh lengkap yang sedikit lebih jelas:

fn main() {
    // Program dimulai dari sini
    let nama = "Alya";
    let kota = "Bandung";

    println!("Halo, {}!", nama);
    println!("Kamu berasal dari {}.", kota);
}

Uraian per baris

  1. fn main() {
    Baris ini mendefinisikan fungsi main, yaitu tempat program mulai berjalan. Tanda { membuka blok kode fungsi.

  2. // Program dimulai dari sini
    Ini adalah komentar. Rust akan mengabaikannya saat program dijalankan.

  3. let nama = "Alya";
    Membuat variabel nama dan mengisinya dengan teks "Alya".

  4. let kota = "Bandung";
    Membuat variabel kota dan mengisinya dengan teks "Bandung".

  5. println!("Halo, {}!", nama);
    Mencetak teks ke layar. Tanda {} diganti dengan isi variabel nama.

  6. println!("Kamu berasal dari {}.", kota);
    Mencetak kalimat kedua dengan memasukkan isi variabel kota.

  7. }
    Menutup blok fungsi main. Setelah ini, isi fungsi selesai.

Jika dijalankan, hasilnya kira-kira seperti ini:

Halo, Alya!
Kamu berasal dari Bandung.

Bagaimana Alur Eksekusi Program Rust?

Pemula sering melihat program sebagai kumpulan baris kode, tetapi penting juga memahami urutan jalannya.

Pada program sederhana Rust, alurnya biasanya seperti ini:

  1. Program dijalankan.
  2. Rust masuk ke fungsi main.
  3. Baris di dalam main dieksekusi dari atas ke bawah.
  4. Saat bertemu let, Rust menyimpan nilai ke variabel.
  5. Saat bertemu println!, Rust mencetak output ke layar.
  6. Ketika mencapai tanda } penutup fungsi, eksekusi fungsi selesai dan program berakhir.

Contohnya, pada kode berikut:

fn main() {
    let nama = "Rani";
    println!("Halo, {}!", nama);
    println!("Program selesai.");
}

Rust tidak akan mencetak Program selesai. lebih dulu. Urutannya tetap dari atas ke bawah. Memahami alur seperti ini sangat membantu saat nanti Anda menulis program yang lebih panjang.

Kesalahan Umum yang Sering Dialami Pemula

Lupa titik koma

let nama = "Rust"
println!("Halo, {}!", nama);

Masalahnya: baris pertama tidak diakhiri titik koma. Solusinya, tambahkan ;.

Kurung kurawal tidak lengkap

fn main() {
    println!("Halo");

Masalahnya: kurung kurawal penutup } hilang. Rust akan menolak mengompilasi kode seperti ini.

Salah menulis nama fungsi utama

fn Main() {
    println!("Halo");
}

Rust membedakan huruf besar dan kecil. Fungsi awal harus bernama main, bukan Main.

Lupa tanda petik untuk teks

let nama = Rust;

Jika yang dimaksud adalah teks, harus ditulis dalam tanda petik:

let nama = "Rust";

Tips Praktis Saat Belajar

  • Tulis program kecil dulu. Jangan buru-buru membuat banyak fitur. Fokus pada satu konsep, misalnya menampilkan teks lalu menyimpan nilai dalam variabel.

  • Baca pesan error Rust dengan tenang. Compiler Rust terkenal cukup membantu. Banyak pesan error-nya menunjukkan lokasi masalah dengan jelas.

  • Perhatikan pasangan tanda. Cek (), {}, tanda petik "", dan titik koma ;.

  • Gunakan komentar seperlunya. Komentar paling berguna saat menjelaskan alasan, bukan hanya mengulang isi kode.

  • Ubah contoh sedikit demi sedikit. Misalnya ganti isi variabel nama, tambah satu println!, atau coba hapus titik koma untuk melihat error yang muncul. Ini cara belajar yang efektif.

Penutup

Struktur dasar program Rust sebenarnya tidak rumit jika dipelajari bagian demi bagian. Untuk mulai menulis program sederhana, Anda cukup mengenali beberapa elemen inti: fungsi main sebagai titik awal, let untuk membuat variabel, println! untuk menampilkan output, komentar untuk memberi penjelasan, titik koma untuk mengakhiri pernyataan, serta kurung kurawal untuk membentuk blok kode.

Yang tak kalah penting, pahami juga bahwa program Rust dasar berjalan dari atas ke bawah di dalam fungsi main. Begitu Anda nyaman dengan pola ini, langkah berikutnya seperti input, fungsi tambahan, kondisi, dan perulangan akan terasa lebih mudah dipahami.

Jika Anda baru mulai belajar Rust, cobalah ketik ulang contoh-contoh di artikel ini, jalankan, lalu ubah beberapa nilainya. Dari latihan sederhana seperti itulah pemahaman yang kuat biasanya mulai terbentuk.