Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Variabel dan Mutability

Seperti yang disebutkan di bagian “Menyimpan Nilai dengan Variabel”, secara default variabel itu immutable. Ini salah satu dari banyak dorongan yang diberikan Rust padamu untuk menulis kode dengan cara yang memanfaatkan kemudahan dan keamanan yang ditawarkan Rust. Meski begitu, kamu tetap bisa membuat variabelmu mutable. Mari kita telusuri bagaimana dan mengapa Rust mendorongmu memilih immutability, serta mengapa terkadang kamu mungkin ingin menyimpang dari itu.

Ketika sebuah variabel immutable, begitu sebuah nilai terikat pada sebuah nama, kamu tidak bisa mengubah nilai itu. Untuk mengilustrasikan hal ini, buat proyek baru bernama variables di direktori projects kamu dengan menggunakan cargo new variables.

Selanjutnya, di direktori variables baru kamu, buka src/main.rs dan ganti isinya dengan kode berikut, yang belum akan terkompilasi:

Filename: src/main.rs

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

Simpan dan jalankan program dengan cargo run. Kamu akan menerima pesan error tentang error immutability, seperti pada output berikut:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         - first assignment to `x`
3 |     println!("The value of x is: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut x = 5;
  |         +++

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` (bin "variables") due to 1 previous error

Contoh ini menunjukkan bagaimana compiler membantumu menemukan error di programmu. Error compiler bisa membuat frustrasi, tapi sebenarnya itu hanya berarti programmu belum dengan aman melakukan apa yang kamu inginkan; itu bukan berarti kamu bukan programmer yang baik! Rustacean berpengalaman pun masih mendapatkan error compiler.

Kamu menerima pesan error cannot assign twice to immutable variable `x` karena kamu mencoba menetapkan nilai kedua pada variabel immutable x.

Penting bagi kita untuk mendapatkan error compile-time ketika mencoba mengubah nilai yang ditetapkan immutable, karena situasi seperti ini bisa menimbulkan bug. Jika satu bagian kode kita bekerja dengan asumsi sebuah nilai tidak akan pernah berubah, sementara bagian kode lain mengubah nilai itu, maka bisa saja bagian pertama tidak melakukan apa yang dirancang untuk dilakukan. Penyebab bug semacam ini bisa sulit dilacak setelah kejadian, terutama ketika potongan kode kedua mengubah nilai itu hanya kadang-kadang. Compiler Rust menjamin bahwa saat kamu menyatakan sebuah nilai tidak akan berubah, nilai itu benar-benar tidak berubah, jadi kamu tidak perlu melacaknya sendiri. Dengan begitu, kode kamu lebih mudah direasoning.

Tapi mutability bisa sangat berguna dan bisa membuat kode lebih nyaman ditulis. Meskipun variabel itu immutable secara default, kamu bisa membuatnya mutable dengan menambahkan mut di depan nama variabel seperti yang kamu lakukan di Bab 2. Menambahkan mut juga menyampaikan niat kepada pembaca kode di masa depan, karena menunjukkan bahwa bagian kode lain akan mengubah nilai variabel tersebut.

Sebagai contoh, mari ubah src/main.rs menjadi berikut:

Filename: src/main.rs

fn main() {
    let mut x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

Ketika kita jalankan programnya sekarang, kita dapat ini:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/variables`
The value of x is: 5
The value of x is: 6

Kita diperbolehkan mengubah nilai yang terikat pada x dari 5 ke 6 saat mut digunakan. Pada akhirnya, memutuskan apakah akan menggunakan mutability atau tidak terserah padamu dan tergantung pada apa yang kamu anggap paling jelas pada situasi tertentu.

Mendeklarasikan Konstanta

Seperti variabel immutable, konstanta adalah nilai yang terikat pada sebuah nama dan tidak boleh berubah, tapi ada beberapa perbedaan antara konstanta dan variabel.

Pertama, kamu tidak boleh menggunakan mut pada konstanta. Konstanta bukan hanya immutable secara default—mereka selalu immutable. Kamu mendeklarasikan konstanta menggunakan keyword const alih-alih keyword let, dan tipe nilai itu harus dianotasi. Kita akan membahas tipe dan anotasi tipe di bagian selanjutnya, “Data Types”, jadi jangan khawatir tentang detailnya sekarang. Cukup ketahui bahwa kamu harus selalu menganotasi tipenya.

Konstanta bisa dideklarasikan di scope mana pun, termasuk scope global, yang membuatnya berguna untuk nilai yang perlu diketahui oleh banyak bagian kode.

Perbedaan terakhir adalah konstanta hanya boleh diset ke sebuah ekspresi konstanta, bukan hasil dari nilai yang hanya bisa dihitung pada runtime.

Berikut contoh deklarasi konstanta:

#![allow(unused)]
fn main() {
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
}

Nama konstanta itu adalah THREE_HOURS_IN_SECONDS, dan nilainya diset ke hasil perkalian 60 (jumlah detik dalam satu menit) dengan 60 (jumlah menit dalam satu jam) dengan 3 (jumlah jam yang ingin kita hitung dalam program ini). Konvensi penamaan Rust untuk konstanta adalah menggunakan huruf kapital semua dengan garis bawah di antara kata-katanya. Compiler mampu mengevaluasi kumpulan operasi terbatas saat compile time, yang memungkinkan kita memilih untuk menulis nilai ini dengan cara yang lebih mudah dipahami dan diverifikasi, alih-alih menyetel konstanta ini ke nilai 10.800. Lihat bagian evaluasi konstanta di Rust Reference untuk informasi lebih lanjut tentang operasi apa yang bisa digunakan saat mendeklarasikan konstanta.

Konstanta berlaku selama program berjalan, di dalam scope tempat mereka dideklarasikan. Sifat ini membuat konstanta berguna untuk nilai-nilai di domain aplikasimu yang mungkin perlu diketahui oleh banyak bagian program, seperti jumlah poin maksimum yang boleh diperoleh setiap pemain dalam sebuah game, atau kecepatan cahaya.

Memberi nama pada nilai hardcoded yang digunakan di seluruh programmu sebagai konstanta berguna untuk menyampaikan makna nilai tersebut kepada para pemelihara kode di masa depan. Ini juga membantu untuk hanya punya satu tempat di kode kamu yang perlu diubah jika nilai hardcoded itu perlu diperbarui di masa depan.

Shadowing

Seperti yang kamu lihat di tutorial guessing game di Bab 2, kamu bisa mendeklarasikan variabel baru dengan nama yang sama dengan variabel sebelumnya. Rustacean menyebut variabel pertama di-shadowing oleh variabel kedua, yang artinya variabel kedualah yang akan dilihat compiler ketika kamu menggunakan nama variabel itu. Secara efektif, variabel kedua menaungi yang pertama, mengambil setiap penggunaan nama variabel itu untuk dirinya sendiri sampai dirinya ikut di-shadowing atau scope berakhir. Kita bisa men-shadow variabel dengan menggunakan nama variabel yang sama dan mengulang penggunaan keyword let seperti berikut:

Filename: src/main.rs

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

Program ini pertama mengikat x ke nilai 5. Lalu, ia membuat variabel baru x dengan mengulang let x =, mengambil nilai awal dan menambahkan 1 sehingga nilai x menjadi 6. Kemudian, di dalam scope inner yang dibuat dengan kurung kurawal, statement let ketiga juga men-shadow x dan membuat variabel baru, mengalikan nilai sebelumnya dengan 2 sehingga x menjadi 12. Ketika scope itu berakhir, shadowing inner berakhir dan x kembali menjadi 6. Ketika kita jalankan program ini, outputnya sebagai berikut:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/variables`
The value of x in the inner scope is: 12
The value of x is: 6

Shadowing berbeda dari menandai sebuah variabel sebagai mut karena kita akan mendapatkan error compile-time jika secara tidak sengaja mencoba menetapkan ulang variabel ini tanpa menggunakan keyword let. Dengan menggunakan let, kita bisa melakukan beberapa transformasi pada sebuah nilai, tapi variabelnya tetap immutable setelah transformasi itu selesai.

Perbedaan lain antara mut dan shadowing adalah karena kita efektifnya membuat variabel baru ketika menggunakan keyword let lagi, kita bisa mengubah tipe nilai itu tapi tetap memakai nama yang sama. Sebagai contoh, misalkan program kita meminta pengguna menunjukkan berapa banyak spasi yang mereka inginkan di antara teks tertentu dengan memasukkan karakter spasi, lalu kita ingin menyimpan input itu sebagai angka:

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
}

Variabel spaces pertama bertipe string, dan variabel spaces kedua bertipe angka. Dengan begitu, shadowing membuat kita tidak perlu memikirkan nama berbeda, seperti spaces_str dan spaces_num; sebagai gantinya, kita bisa memakai ulang nama spaces yang lebih sederhana. Namun, jika kita mencoba menggunakan mut untuk ini, seperti ditunjukkan di sini, kita akan mendapatkan error compile-time:

fn main() {
    let mut spaces = "   ";
    spaces = spaces.len();
}

Error itu mengatakan kita tidak boleh memutasi tipe sebuah variabel:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
2 |     let mut spaces = "   ";
  |                      ----- expected due to this value
3 |     spaces = spaces.len();
  |              ^^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables` (bin "variables") due to 1 previous error

Sekarang setelah kita menelusuri cara kerja variabel, mari kita lihat lebih banyak data types yang bisa dimilikinya.