Variabel di Rust

Variabel hanyalah nama yang kamu berikan pada sebuah nilai supaya bisa dipakai nanti. Bayangkan seperti kotak berlabel: kamu memasukkan sesuatu ke dalam kotak, menulis nama di kotaknya, lalu menyebutnya dengan nama itu alih-alih mengulang nilainya di mana-mana.

Membuat variabel

Di Rust, kamu membuat variabel dengan keyword let:

fn main() {
    let age = 30;
    println!("Umur saya {age} tahun");
}

Output:

Umur saya 30 tahun

▶ Coba sendiri

Mari kita uraikan baris itu:

• let: memberi tahu Rust “aku sedang membuat variabel baru.”
• age: nama yang kita pilih.
• =: memberikan nilai di sebelah kanan ke nama di sebelah kiri.
• 30: nilai yang kita simpan.

{age} di dalam println! mencetak nilai variabel tersebut. Ini disebut string interpolation: Rust mengganti {age} dengan apa pun isi age.

Rust menebak tipenya untukmu

Setiap nilai di Rust punya tipe (bilangan bulat, teks, true/false, dan sebagainya). Kamu mungkin mengira harus menuliskan tipenya, tapi biasanya tidak perlu. Rust melihat nilainya dan mencari tahu sendiri. Ini disebut type inference (inferensi tipe).

fn main() {
    let score = 95;        // Rust menyimpulkan ini bilangan bulat
    let name = "Ferris";   // Rust menyimpulkan ini teks
    let is_active = true;  // Rust menyimpulkan ini boolean
    println!("{name}: {score}, aktif = {is_active}");
}

Output:

Ferris: 95, aktif = true

▶ Coba sendiri

Kalau kamu ingin menuliskannya secara eksplisit, tulis tipenya setelah titik dua:

let score: i32 = 95; // i32 = bilangan bulat 32-bit

Catatan

i32 artinya “bilangan bulat yang muat dalam 32 bit.” Jangan khawatirkan tipe-tipe yang persis dulu. Kita membahasnya lengkap di Tipe data. Untuk sekarang, membiarkan Rust menebak tipenya sudah sangat cukup.

Variabel bersifat immutable secara default

Ini bagian yang sering mengejutkan orang yang datang dari bahasa lain: di Rust, setelah kamu mengisi sebuah variabel, secara default kamu tidak bisa mengubahnya. “Immutable” artinya tidak dapat diubah.

Kode ini tidak akan bisa di-compile:

fn main() {
    let count = 1;
    count = 2; // ❌ error: tidak bisa mengisi dua kali variabel yang immutable
    println!("{count}");
}

Compiler menghentikanmu dengan pesan yang jelas:

error[E0384]: cannot assign twice to immutable variable `count`

Artinya: variabel count yang immutable tidak bisa diisi dua kali.

Kenapa sebuah bahasa sengaja melakukan ini? Karena banyak bug muncul dari nilai yang berubah padahal kamu tidak menduganya. Dengan membuat segala sesuatu tidak bisa diubah kecuali kamu memintanya, Rust membuat kodemu lebih mudah ditebak. Ini fitur, bukan keterbatasan.

Membuat variabel bisa diubah dengan mut

Kalau kamu memang butuh sebuah nilai berubah, tambahkan keyword mut (singkatan dari mutable = dapat diubah):

fn main() {
    let mut count = 1;
    println!("Sebelum: {count}");

    count = 2; // ✅ sekarang boleh, karena ada `mut`
    println!("Sesudah: {count}");
}

Output:

Sebelum: 1
Sesudah: 2

▶ Coba sendiri

Tips

Kebiasaan yang baik: mulailah tanpa mut. Tambahkan hanya ketika compiler protes bahwa kamu sedang mencoba mengubah sebuah nilai. Dengan begitu, variabelmu tetap immutable kecuali benar-benar perlu diubah.

Shadowing: memakai ulang nama yang sama

Rust membolehkanmu mendeklarasikan variabel baru dengan nama yang sama seperti variabel lama. Ini disebut shadowing (membayangi): variabel baru “membayangi” variabel yang lama:

fn main() {
    let x = 5;
    let x = x + 1;   // x baru, berdasarkan x lama -> 6
    let x = x * 2;   // x baru lagi -> 12
    println!("x bernilai {x}");
}

Output:

x bernilai 12

▶ Coba sendiri

Ini terlihat mirip dengan mut, tapi sebenarnya berbeda:

• mut mengubah nilai dari variabel yang sama.
• Shadowing membuat variabel yang benar-benar baru yang kebetulan memakai nama yang sama, dan tipenya bahkan bisa berbeda.

Shadowing berguna saat kamu ingin mengubah bentuk sebuah nilai tapi tetap memakai nama yang sama:

fn main() {
    let spaces = "   ";        // teks
    let spaces = spaces.len(); // sekarang angka (berapa banyak spasinya)
    println!("Jumlah spasi: {spaces}");
}

Output:

Jumlah spasi: 3

▶ Coba sendiri

Konstanta

Konstanta adalah nilai yang tidak pernah berubah dan sudah ditetapkan saat compile. Kamu mendeklarasikannya dengan const, bukan let, dan kamu wajib menuliskan tipenya:

const MAX_SCORE: u32 = 100;

fn main() {
    println!("Skor maksimal adalah {MAX_SCORE}");
}

Output:

Skor maksimal adalah 100

▶ Coba sendiri

Sesuai konvensi, konstanta ditulis dengan UPPER_SNAKE_CASE. Ini perbandingannya dengan variabel biasa:

	Variabel let	Konstanta const
Bisa diubah?	Hanya dengan mut	Tidak pernah
Tipe wajib ditulis?	Opsional (ditebak otomatis)	Wajib
Gaya penamaan	snake_case	UPPER_SNAKE_CASE
Boleh ditulis di mana	Di dalam fungsi	Di mana saja, bahkan di luar fungsi

Pakai konstanta untuk nilai yang benar-benar tetap, seperti jumlah detik dalam satu menit, atau batas maksimal.

Aturan penamaan

• Pakai snake_case, yaitu kata-kata huruf kecil yang disambung dengan garis bawah: user_name, total_price.
• Nama boleh berisi huruf, angka, dan garis bawah, tapi tidak boleh diawali angka.
• Pilih nama yang deskriptif: age lebih baik daripada a.

Kesalahan umum pemula

• Lupa menulis mut saat kamu perlu mengubah sebuah nilai → cannot assign twice to immutable variable.
• Memakai variabel sebelum membuatnya → Rust butuh let ditulis lebih dulu.
• Variabel yang tidak dipakai memunculkan warning. Kalau memang disengaja, awali namanya dengan garis bawah: let _unused = 5;.

Latihan

1. Naik level

Buat variabel level yang dimulai dari 1. Cetak nilainya, naikkan 1 sebanyak dua kali, dan cetak setiap kali berubah, sehingga kamu mendapat Level 1, Level 2, Level 3. Petunjuk: nilai yang berubah butuh mut, dan level = level + 1; menambahkan satu.

Lihat solusi

fn main() {
    let mut level = 1;
    println!("Level {level}");

    level = level + 1;
    println!("Level {level}");

    level = level + 1;
    println!("Level {level}");
}

Output:

Level 1
Level 2
Level 3

▶ Coba sendiri

2. Menit ke detik

Deklarasikan konstanta SECONDS_PER_MINUTE yang bernilai 60. Mulai dengan let time = 5; (dalam menit), lalu lakukan shadowing pada time supaya isinya durasi yang sama dalam detik, dan cetak Itu sama dengan 300 detik. Petunjuk: time yang baru bisa dibuat dari yang lama: let time = time * ...;.

Lihat solusi

const SECONDS_PER_MINUTE: u32 = 60;

fn main() {
    let time = 5; // menit
    let time = time * SECONDS_PER_MINUTE; // `time` yang baru, sekarang dalam detik
    println!("Itu sama dengan {time} detik");
}

Output:

Itu sama dengan 300 detik

▶ Coba sendiri

Tidak perlu mut: let yang kedua membuat variabel yang benar-benar baru dengan nama yang sama. Rust juga menyimpulkan bahwa time di sini bertipe u32, karena dikalikan dengan konstanta u32.

Ringkasan

• Buat variabel dengan let; biasanya Rust menebak tipenya untukmu.
• Variabel bersifat immutable secara default. Tambahkan mut supaya bisa diubah.
• Shadowing mendeklarasikan ulang sebuah nama dengan let, sehingga tercipta variabel baru (tipenya boleh berbeda).
• Konstanta (const) tidak pernah berubah, selalu butuh tipe, dan ditulis dengan UPPER_SNAKE_CASE.

Kuis singkat

Kuis singkat

1. Secara default, bisakah kamu mengisi ulang variabel let di Rust?

Ya, selalu bisa Tidak, kecuali dideklarasikan dengan mut Hanya kalau isinya angka

2. Apa itu shadowing di Rust?

Mendeklarasikan variabel baru dengan let yang memakai ulang nama yang sudah ada Menyembunyikan variabel dari fungsi lain Membuat variabel menjadi private

3. Menurut halaman ini, konvensi penamaan apa yang dipakai untuk variabel Rust?

camelCase PascalCase snake_case

Skor: 0 / 3

Bacaan lebih lanjut

• Variables and Mutability — The Rust Book (bahasa Inggris): bab resmi tentang let, mut, konstanta, dan kenapa immutable menjadi default.
• Shadowing — The Rust Book (bahasa Inggris): penjelasan lebih lanjut tentang perbedaan shadowing dan mut, termasuk mengganti tipe sebuah nilai.
• Variable Bindings — Rust by Example (bahasa Inggris): contoh singkat yang bisa dijalankan, dilanjutkan dengan mutability serta scope dan shadowing.
• Constants — Rust by Example (bahasa Inggris): const (dan saudaranya, static) dalam sebuah program kecil.
• let keyword — standard library docs (bahasa Inggris): semua yang bisa dilakukan let, untuk saat kamu ingin gambaran lengkapnya.