Foundation

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:

RSRUST
fn main() {
    let x = 5;
    println!("x = {x}");
}
CodeTEXT
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:

RSRUST
fn main() {
    let mut y = 5;
    y = 10;
    println!("y = {y}");
}
CodeTEXT
y = 10

Tanpa mut, baris y = 10; ditolak:

RSRUST
fn main() {
    let hitungan = 1;
    hitungan = 2;
    println!("{hitungan}");
}
CodeTEXT
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:

RSRUST
fn main() {
    let z: i64 = 1_000_000;
    println!("z = {z}");
}
CodeTEXT
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:

RSRUST
fn main() {
    let umur = 30;
    umur = "tiga puluh";
    println!("{umur}");
}
CodeTEXT
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:

RSRUST
fn main() {
    let umur = 30;
    umur = 31;
    println!("{umur}");
}
CodeTEXT
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:

RSRUST
fn main() {
    let nanti: i32;
    nanti = 7;
    println!("{nanti}");
}
CodeTEXT
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:

RSRUST
fn main() {
    let mut y = 5;
    y = 10;
    println!("y = {y}");

    let namaDepan = "Aziz";
    println!("{namaDepan}");
}
CodeTEXT
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.

PeringatanPenyebabPerbaikan
unused_variablesnilai tidak pernah dipakaihapus, atau awali nama dengan _
unused_assignmentsnilai pertama langsung digantihapus pemberian nilai pertama
non_snake_casenama memakai camelCaseubah menjadi snake_case

Variabel tidak dipakai

Variabel yang tidak pernah dipakai dilaporkan sebagai peringatan. Kalau memang disengaja, awali nama dengan garis bawah:

RSRUST
fn main() {
    let _tidak_dipakai = 5;
    println!("selesai tanpa peringatan");
}
CodeTEXT
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.

Contoh kecil yang memakai mut dan variabel sementara: menukar isi 2 variabel. Tanpa variabel sementara, nilai pertama akan tertimpa sebelum sempat disalin.

RSRUST
fn main() {
    let mut a = 1;
    let mut b = 2;

    let sementara = a;
    a = b;
    b = sementara;

    println!("a = {a}, b = {b}");
}
CodeTEXT
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:

  1. Nama variabel menjelaskan isinya, misalnya jumlahPeserta menjadi jumlah_peserta.
  2. Nama boolean dibaca sebagai pertanyaan, misalnya sudah_bayar atau is_active.
  3. Nama yang terlalu panjang dipersingkat dengan konteks, misalnya total_harga di 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.

  1. Buat 3 binding: 1 tanpa mut, 1 dengan mut, dan 1 dengan anotasi i64. Ubah nilai yang bertanda mut, lalu kompilasi dan jalankan.
  2. Tulis nama binding dengan camelCase, kompilasi, dan baca peringatan yang muncul. Perbaiki namanya menjadi snake_case.
  3. Tulis program yang menukar nilai 3 variabel secara berputar, lalu periksa hasilnya dengan mencetak ketiganya.
  4. Hapus kata kunci mut dari 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

  1. The Rust Programming Language. Variables and Mutability.
  2. The Rust Reference. Let statements.
  3. The rustc book. Warn-by-default lints.