Lompati ke konten utama
Modul 1 · Pelajaran 1 dari 21/14 dalam kursus~10 min
Pelajaran modul (1/2)

Variabel dan Mutabilitas

Di Rust, manajemen variabel dan memori dipandu oleh dua prinsip dasar: keamanan dan kontrol. Oleh karena itu, tidak seperti banyak bahasa pemrograman lainnya, variabel di Rust tidak dapat diubah secara default.

Artinya, ketika suatu nilai telah ditetapkan ke suatu variabel, maka nilai tersebut tidak dapat diubah. Jika Anda mencoba memodifikasinya, kompiler akan memunculkan kesalahan.

Variabel Abadi dan Kata Kunci mut

Untuk mendeklarasikan variabel, kita menggunakan kata kunci let :

Rust
let x = 5; // Immutable by default
// x = 6; // ERROR! The compiler will refuse to build this code.

Jika Anda perlu mengubah nilai suatu variabel, Anda harus secara eksplisit membuatnya dapat diubah dengan menggunakan kata kunci mut tepat setelah let:

Rust
let mut y = 10; // Mutable
println!("Il valore di y e: {}", y);
y = 15; // Valid!
println!("Il valore modificato di y e: {}", y);

Menggunakan awalan mut dengan jelas mengkomunikasikan kepada kompiler dan siapa pun yang membaca kode bahwa nilainya akan berubah selama eksekusi.

Pembayangan

Rust juga mengizinkan konsep shadowing, yaitu deklarasi ulang variabel dengan nama yang sama menggunakan kata kunci let lagi. Variabel baru "membayangi" (atau menutupi) variabel sebelumnya:

Rust
let x = 5;
let x = x + 1; // Shadowing: x is now 6
let x = x * 2; // Shadowing: x is now 12

Berbeda dengan mut, shadowing memungkinkan Anda untuk:

  1. Ubah tipe data variabel dengan tetap menggunakan nama yang sama.
  2. Pertahankan kekekalan variabel setelah transformasi.
Rust
let spaces = "   "; // Type: &str (string)
let spaces = spaces.len(); // Type: usize (number)

Kegunaan Shadowing dan Scope

Membayangi tidak terbatas pada blok yang sama; itu dapat digunakan dalam blok bersarang ({}) untuk mengganti nilai sementara. Ketika blok dalam berakhir, variabel asli menjadi terlihat kembali:

Rust
let x = 5;
{
    let x = x * 2; // Shadowing valid only inside the block
    println!("Value in the inner block: {}", x); // Prints 10
}
println!("Value in the outer block: {}", x); // Prints 5

Mekanisme ini sangat aman dan efisien karena terjadi sepenuhnya pada waktu kompilasi, memastikan keamanan jenis tanpa overhead kinerja waktu proses.


Cobalah sendiri

Latihan#rust.m1.l1.e1
Upaya: 0Memuat…

Deklarasikan variabel yang bisa berubah bernama x dengan nilai awal 5. Selanjutnya, tambahkan 10 ke x dan cetak ke layar menggunakan println! makro.

Memuat editor…
Tunjukkan petunjuk

Deklarasikan variabel dengan `let mut x = 5;`, lalu tambahkan dengan `x += 10;` (atau `x = x + 10;`) dan terakhir cetak dengan `println!('{}', x);`.

Solusi tersedia setelah 3 upaya

Latihan#rust.m1.l1.e2
Upaya: 0Memuat…

Deklarasikan variabel abadi y dengan nilai 10. Bayangkan y dengan mendeklarasikannya lagi dengan let untuk mengalikan nilai sebelumnya dengan 2, dan terakhir mencetaknya menggunakan println!.

Memuat editor…
Tunjukkan petunjuk

Use `let y = 10;`, then shadow it by declaring it again with `let y = y * 2;` and finally use `println!` to display it.

Solusi tersedia setelah 3 upaya

Latihan#rust.m1.l1.e3
Upaya: 0Memuat…

Declare an immutable variable named input containing the string value "42". Shadow input by declaring it as an integer of type i32, converting the original value via input.parse::<i32>().unwrap(). Finally, print it using the println! macro.

Memuat editor…
Tunjukkan petunjuk

Declare `let input = "42";`, then shadow it with `let input: i32 = input.parse().unwrap();` and print it using `println!("{}", input);`.

Solusi tersedia setelah 3 upaya