BAB 4: Variabel
Variabel di Rust: let, mut, anotasi tipe, deklarasi tanpa nilai, serta peringatan kompilator untuk nama dan nilai yang tidak dipakai.
Variabel di Rust tidak bisa diubah setelah dibuat, kecuali dideklarasikan dengan mut. Aturan itu terasa mengganggu di awal, sampai pesan kompilator menunjukkan bahwa kesalahan yang biasanya baru terlihat saat program berjalan sudah ditolak sebelum biner dibuat.
Bab ini membahas let, mut, anotasi tipe, dan 3 peringatan kompilator yang muncul pada penulisan variabel. Semua contoh dikompilasi dengan rustc 1.100.0, dan keluarannya diambil dari program yang dijalankan.
let membuat binding
let mengikat nilai ke nama. Binding yang dibuat dengan let tidak bisa diubah:
fn main() {
let x = 5;
println!("x = {x}");
}
x = 5
Baris let x = 5; dibaca sebagai "ikat nilai 5 ke nama x", bukan "buat variabel x berisi 5". Perbedaan istilah ini berguna saat membaca pesan kompilator, karena pesan itu memakai kata binding dan immutable.
mut membuat nilai bisa diubah
Untuk mengubah nilai, nama harus dideklarasikan dengan mut:
fn main() {
let mut y = 5;
y = 10;
println!("y = {y}");
}
y = 10
Tanpa mut, baris y = 10; ditolak:
fn main() {
let hitungan = 1;
hitungan = 2;
println!("{hitungan}");
}
error[E0384]: cannot assign twice to immutable variable `hitungan`
|
2 | let hitungan = 1;
| -------- first assignment to `hitungan`
3 | hitungan = 2;
| ^^^^^^^^^^^^^ cannot assign twice to immutable variable
Kompilator menyebut 2 hal sekaligus: baris yang membuat binding, dan baris yang mencoba mengubahnya. Untuk memperbaiki, tambahkan mut pada baris pertama.
Anotasi tipe
Tipe variabel biasanya ditentukan kompilator dari nilainya. Kalau perlu ditegaskan, tulis tipe setelah nama:
fn main() {
let z: i64 = 1_000_000;
println!("z = {z}");
}
z = 1000000
Garis bawah pada 1_000_000 hanya pemisah agar angka mudah dibaca, dan tidak memengaruhi nilainya. Anotasi tipe dipakai ketika nilai tidak cukup menjelaskan tipe yang diinginkan, misalnya saat angka akan dipakai bersama fungsi yang menuntut tipe tertentu.
Kalau nilai yang diberikan tidak sesuai anotasi, kompilasi berhenti:
fn main() {
let umur = 30;
umur = "tiga puluh";
println!("{umur}");
}
error[E0308]: mismatched types
|
2 | let umur = 30;
| -- expected due to this value
3 | umur = "tiga puluh";
| ^^^^^^^^^^^^ expected integer, found `&str`
Pada contoh itu ada 2 kesalahan sekaligus: umur tidak mutable, dan tipe nilainya berbeda. Kompilator melaporkan kesalahan tipe lebih dulu, yaitu E0308. Kalau nilainya diganti dengan angka yang tipenya sama, kesalahan yang muncul berubah menjadi E0384:
fn main() {
let umur = 30;
umur = 31;
println!("{umur}");
}
error[E0384]: cannot assign twice to immutable variable `umur`
|
2 | let umur = 30;
| ---- first assignment to `umur`
3 | umur = 31;
| ^^^^^^^^^ cannot assign twice to immutable variable
|
help: consider making this binding mutable
2 kesalahan itu memang berbeda: yang pertama soal tipe, yang kedua soal izin mengubah nilai.
Deklarasi tanpa nilai
Binding boleh dideklarasikan tanpa nilai, asalkan tipenya ditulis dan nilainya diberikan sebelum dipakai:
fn main() {
let nanti: i32;
nanti = 7;
println!("{nanti}");
}
7
Bentuk ini berguna ketika nilai baru tersedia setelah beberapa langkah, misalnya setelah membaca masukan. Kalau nilai tidak pernah diberikan, kompilator menolak dengan pesan bahwa binding dipakai sebelum diinisialisasi.
Peringatan untuk nama dan nilai
Rust membedakan kesalahan yang menghentikan kompilasi dari peringatan yang hanya memberi tahu. 2 peringatan yang sering muncul pada variabel:
fn main() {
let mut y = 5;
y = 10;
println!("y = {y}");
let namaDepan = "Aziz";
println!("{namaDepan}");
}
warning: value assigned to `y` is never read
|
5 | let mut y = 5;
| ^ this value is reassigned later and never used
6 | y = 10;
| ------ `y` is overwritten here before the previous value is read
warning: variable `namaDepan` should have a snake case name
--> variabel_demo.rs:12:9
Peringatan pertama muncul karena nilai 5 tidak pernah dibaca sebelum diganti menjadi 10. Peringatan kedua muncul karena nama variabel di Rust ditulis dengan huruf kecil dan garis bawah, bukan camelCase. Keduanya tidak menghentikan kompilasi, tetapi menunjukkan kode yang bisa dirapikan.
| Peringatan | Penyebab | Perbaikan |
|---|---|---|
unused_variables | nilai tidak pernah dipakai | hapus, atau awali nama dengan _ |
unused_assignments | nilai pertama langsung diganti | hapus pemberian nilai pertama |
non_snake_case | nama memakai camelCase | ubah menjadi snake_case |
Variabel tidak dipakai
Variabel yang tidak pernah dipakai dilaporkan sebagai peringatan. Kalau memang disengaja, awali nama dengan garis bawah:
fn main() {
let _tidak_dipakai = 5;
println!("selesai tanpa peringatan");
}
selesai tanpa peringatan
Garis bawah memberitahu kompilator bahwa nama itu sengaja tidak dipakai, dan sekaligus memberitahu pembaca berikutnya. Ini berbeda dari atribut #[allow(unused_variables)] yang mematikan pemeriksaan untuk seluruh item.
Menukar nilai 2 variabel
Contoh kecil yang memakai mut dan variabel sementara: menukar isi 2 variabel. Tanpa variabel sementara, nilai pertama akan tertimpa sebelum sempat disalin.
fn main() {
let mut a = 1;
let mut b = 2;
let sementara = a;
a = b;
b = sementara;
println!("a = {a}, b = {b}");
}
a = 2, b = 1
3 langkah itu harus berurutan. Kalau a = b; dijalankan sebelum let sementara = a;, nilai lama a hilang dan kedua variabel berisi 2. Kesalahan urutan seperti ini tidak ditolak kompilator, karena semuanya sah secara tipe.
Nama yang baik
Kompilator hanya memeriksa bentuk nama, bukan maknanya. Nama x dan data1 lolos pemeriksaan, tetapi tidak membantu pembaca. 3 patokan yang saya pakai:
- Nama variabel menjelaskan isinya, misalnya
jumlahPesertamenjadijumlah_peserta. - Nama boolean dibaca sebagai pertanyaan, misalnya
sudah_bayaratauis_active. - Nama yang terlalu panjang dipersingkat dengan konteks, misalnya
total_hargadi dalam fungsi yang memang menghitung harga.
Nama yang jelas mengurangi kebutuhan komentar, dan pada Rust hal itu penting karena tipe sering sudah terlihat dari nama.
Latihan
Latihan berikut memakai perintah yang sama seperti contoh di atas: rustc berkas.rs lalu jalankan binernya. Setiap kesalahan yang muncul saat kompilasi adalah bagian dari latihan, jadi baca pesannya sebelum memperbaiki.
- Buat 3 binding: 1 tanpa
mut, 1 denganmut, dan 1 dengan anotasii64. Ubah nilai yang bertandamut, lalu kompilasi dan jalankan. - Tulis nama binding dengan camelCase, kompilasi, dan baca peringatan yang muncul. Perbaiki namanya menjadi
snake_case. - Tulis program yang menukar nilai 3 variabel secara berputar, lalu periksa hasilnya dengan mencetak ketiganya.
- Hapus kata kunci
mutdari program yang berhasil, kompilasi ulang, dan catat nomor kesalahan yang muncul.
Ringkasan
let membuat binding yang tidak bisa diubah, dan mut membuat nilainya bisa diganti. Tipe ditentukan dari nilai, dan bisa ditegaskan dengan anotasi setelah nama. Binding boleh dideklarasikan tanpa nilai selama tipenya ditulis dan nilainya diberikan sebelum dipakai.
3 peringatan yang sering muncul pada variabel: nilai yang tidak pernah dipakai, nilai yang langsung diganti tanpa dibaca, dan nama yang tidak memakai snake_case. Mengubah nilai tanpa mut bukan peringatan, melainkan kesalahan kompilasi E0384 yang menghentikan pembuatan biner.
Referensi
- The Rust Programming Language. Variables and Mutability.
- The Rust Reference. Let statements.
- The rustc book. Warn-by-default lints.