BAB 31: Shadowing
Shadowing membuat binding baru dengan nama yang sama, bisa berganti tipe, dan berbeda dari mut karena nilai lama tidak bisa diubah.
Kode berikut mencetak 10, 15, dan 30 dari 1 nama variabel yang sama. Baris let nilai = 10; diikuti let nilai = nilai + 5; tidak menghasilkan kesalahan, karena let kedua membuat binding baru yang membayangi binding pertama, bukan mengubah nilai yang lama. Buku resmi Rust menyebutnya dengan kalimat "the first variable is shadowed by the second, which means that the second variable is what the compiler will see when you use the name of the variable".
Shadowing sering disalahpahami sebagai pengganti mut, padahal keduanya menyelesaikan masalah yang berbeda. mut memberi izin menulis ulang 1 nilai, sedangkan shadowing meninggalkan nilai lama dan membuat nama baru yang menunjuk ke nilai lain, bahkan dengan tipe yang berbeda.
Setelah bab ini selesai, kamu dapat memakai shadowing untuk mengubah tipe di tengah pengolahan data, membedakan shadowing dari mut, membaca peringatan unused_variables yang muncul karena shadowing, dan mengenali E0308 serta E0384 yang sering muncul saat keduanya tertukar. Semua contoh dijalankan dengan rustc 1.100.0 pada folder /tmp/latihan-rust/bab31.
let kedua membayangi let pertama
Contoh pertama memakai 1 nama untuk 3 tahap perhitungan. Setiap tahap memakai nilai dari tahap sebelumnya.
fn main() {
let nilai = 10;
println!("{}", nilai);
let nilai = nilai + 5;
println!("{}", nilai);
let nilai = nilai * 2;
println!("{}", nilai);
}
10
15
30
Baris let nilai = nilai + 5; membaca nilai lama (10) di sisi kanan, lalu membuat binding baru bernama nilai yang berisi 15. Binding lama masih ada di memori sampai blok selesai, tetapi namanya sudah tidak bisa dipakai lagi. Karena itu baris ketiga membaca 15, bukan 10.
Kompilator memperlakukan setiap let sebagai deklarasi terpisah. Tidak ada perubahan pada nilai yang sudah ada, dan tidak ada izin tulis yang diberikan ke variabel lama.
Shadowing dan mut mengubah hal berbeda
mut membuat 1 binding boleh ditulis ulang. Shadowing membuat binding baru. Contoh berikut memakai keduanya pada nama yang sama untuk memperlihatkan bedanya.
fn main() {
let mut hitungan = 1;
hitungan = hitungan + 1;
println!("{}", hitungan);
let hitungan = hitungan + 1;
println!("{}", hitungan);
}
2
3
Baris hitungan = hitungan + 1; adalah penugasan ke binding yang sama, dan itu hanya sah karena hitungan dideklarasikan dengan mut. Baris let hitungan = hitungan + 1; adalah deklarasi binding baru, sehingga mut tidak lagi diperlukan setelah baris itu. Kalau baris pertama diganti menjadi let hitungan = 1; tanpa mut, kompilator menolak penugasan di baris kedua dengan E0384.
Buku resmi Rust menjelaskan bedanya dari sisi kesalahan yang dicegah: "we'll get a compile-time error if we accidentally try to reassign to this variable without using the let keyword". Dengan mut, penulisan ulang yang tidak disengaja lolos kompilasi. Dengan shadowing, penulisan ulang harus ditulis sebagai let baru, sehingga perubahan nilainya terlihat saat membaca kode.
Mengganti tipe dengan nama yang sama
Keuntungan kedua dari shadowing adalah tipe boleh berubah. Variabel data di bawah ini berubah dari &str menjadi &str yang sudah dipangkas, lalu menjadi usize.
fn main() {
let data = " teks ";
println!("[{}]", data);
let data = data.trim();
println!("[{}] panjang {}", data, data.len());
let data = data.len();
println!("{}", data);
}
[ teks ]
[teks] panjang 4
4
Binding pertama bertipe &str berisi 10 karakter dengan spasi di kedua sisi. trim() mengembalikan &str baru tanpa spasi, dan binding kedua memakai nama yang sama sehingga tahap berikutnya tidak perlu memikirkan spasi lagi. Binding ketiga menyimpan usize hasil len(). Buku resmi Rust menyebut kemampuan ini dengan kalimat "we can change the type of the value but reuse the same name".
Dengan mut, perubahan tipe seperti ini tidak bisa dilakukan. 1 binding hanya punya 1 tipe, dan let mut data = " teks "; lalu data = data.len(); ditolak kompilator karena usize bukan &str.
Rantai pengolahan masukan
Pola yang paling sering dipakai di kode nyata adalah rantai shadowing untuk membersihkan masukan sebelum dipakai. Setiap langkah memakai nama yang sama supaya tahap sesudahnya tidak perlu memilih nama baru.
fn main() {
let masukan = " 42 ";
let masukan = masukan.trim();
let masukan: i32 = masukan.parse().expect("bukan angka");
let masukan = masukan * 2;
println!("{}", masukan);
}
84
Baris pertama menyimpan teks mentah, baris kedua memangkas spasi, baris ketiga mengubah teks menjadi i32 dengan anotasi tipe, dan baris keempat menggandakan angkanya. Anotasi : i32 pada baris ketiga diperlukan karena parse bisa menghasilkan banyak tipe, dan tanpa anotasi kompilator tidak tahu tipe mana yang dipilih.
Rantai seperti ini lebih mudah dibaca daripada masukan_mentah, masukan_bersih, masukan_angka, dan masukan_akhir. Setiap nama tambahan menuntut pembaca mengingat bedanya, sementara isi setiap tahap sudah dijelaskan oleh baris let itu sendiri.
Cakupan shadowing berhenti di blok
Shadowing di blok dalam tidak mengubah binding di blok luar. Contoh berikut memakai nama nama di 2 tingkat.
fn main() {
let nama = "luar";
println!("{}", nama);
{
let nama = "dalam";
println!("{}", nama);
}
println!("{}", nama);
}
luar
dalam
luar
Binding di dalam blok hanya berlaku di blok itu. Setelah kurung kurawal penutup, nama nama kembali menunjuk binding pertama yang berisi luar. Buku resmi Rust menulis batas ini sebagai "until either it itself is shadowed or the scope ends".
Perilaku ini berbeda dari mut pada variabel luar. Kalau blok dalam menulis nama = "dalam" pada binding mut di luar, nilai setelah blok ikut berubah. Shadowing tidak bisa mengubah binding luar, dan itu yang membuatnya aman dipakai untuk perhitungan sementara.
Membekukan nilai setelah mut
Pola lain yang lazim adalah memakai mut selama perhitungan, lalu menutupnya dengan let tanpa mut. Setelah baris itu, nilai tidak bisa diubah lagi.
fn main() {
let mut total = 0;
for n in 1..=4 {
total += n;
}
let total = total * 100;
println!("{}", total);
}
1000
total harus mut selama loop karena nilainya bertambah di setiap putaran. Setelah loop selesai, baris let total = total * 100; membuat binding baru tanpa mut, sehingga kode sesudahnya tidak bisa menambah atau mengurangi nilainya. Buku resmi Rust menyebut manfaat ini dengan kalimat "we can perform a few transformations on a value but have the variable be immutable after those transformations have completed".
Pola ini berguna pada fungsi panjang: bagian perhitungan boleh memakai mut, dan bagian pemakaian mendapat jaminan bahwa nilai tidak berubah lagi.
Nilai lama yang tidak terbaca
Kompilator bisa menunjukkan binding yang tertimpa tanpa pernah dibaca. Contoh berikut mendeklarasikan nilai 2 kali dan hanya memakai yang kedua.
fn main() {
let nilai = 10;
let nilai = 20;
println!("{}", nilai);
}
warning: unused variable: `nilai`
--> nilai_tak_terbaca.rs:2:9
|
2 | let nilai = 10;
| ^^^^^ help: if this is intentional, prefix it with an underscore: `_nilai`
|
= note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
warning: 1 warning emitted
20
Peringatan menunjuk baris pertama, bukan baris kedua, karena binding pertama itulah yang tidak pernah dipakai. Program tetap berjalan dan mencetak 20. Peringatan unused_variables di sini berguna sebagai penanda bahwa 1 baris let bisa dihapus tanpa mengubah perilaku program.
Perhatikan juga bahwa shadowing tidak menghapus nilai lama dari memori seketika. Binding lama tetap hidup sampai blok selesai, dan pada tipe yang memiliki destruktor, pembebasannya terjadi saat blok berakhir.
2 kesalahan setelah shadowing
Kesalahan pertama muncul saat nama yang sudah dibayangi dipakai dengan tipe lamanya. Kode ini sengaja salah.
fn main() {
let nilai = 10;
let nilai = format!("{}", nilai);
println!("{}", nilai + 1);
}
error[E0308]: mismatched types
--> salah_tipe_setelah_shadow.rs:5:28
|
5 | println!("{}", nilai + 1);
| ^ expected `&str`, found integer
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0308`.
format! mengembalikan String, sehingga nilai yang dipakai di baris kelima bertipe String, bukan i32 lagi. Operator + pada String hanya menerima &str di sisi kanan, dan itulah yang dilaporkan kompilator: expected &str, found integer. Shadowing tidak mengubah tipe nilai lama dan tidak menambahkan konversi otomatis. Perbaikannya adalah memakai nilai.parse::<i32>() sebelum penjumlahan, atau memakai format! untuk seluruh hasil.
Kesalahan kedua muncul saat binding hasil shadowing dicoba ditimpa tanpa let.
fn main() {
let nilai = 5;
let nilai = nilai + 1;
nilai = 0;
println!("{}", nilai);
}
error[E0384]: cannot assign twice to immutable variable `nilai`
--> salah_timpa_shadow.rs:4:5
|
3 | let nilai = nilai + 1;
| ----- first assignment to `nilai`
4 | nilai = 0;
| ^^^^^^^^^ cannot assign twice to immutable variable
|
help: consider making this binding mutable
|
3 | let mut nilai = nilai + 1;
| +++
warning: value assigned to `nilai` is never read
--> salah_timpa_shadow.rs:3:17
|
3 | let nilai = nilai + 1;
| ^^^^^^^^^ this value is reassigned later and never used
4 | nilai = 0;
| --------- `nilai` is overwritten here before the previous value is read
|
= note: `#[warn(unused_assignments)]` (part of `#[warn(unused)]`) on by default
error: aborting due to 1 previous error; 1 warning emitted
For more information about this error, try `rustc --explain E0384`.
Kompilator menunjuk baris let nilai = nilai + 1; sebagai pemberian nilai pertama, lalu menolak nilai = 0; karena binding itu tidak mut. Saran yang muncul adalah menambahkan mut, tetapi pilihan lain yang lebih sesuai maksud kode adalah memakai let nilai = 0; kalau memang ingin nilai baru. Perhatikan juga peringatan unused_assignments yang menyebut nilai 6 tidak pernah terbaca, tanda bahwa baris penugasan itu memang salah sejak awal.
Kapan shadowing dipakai
Shadowing cocok dipakai saat 1 nilai melewati beberapa tahap dan setiap tahap mengubah bentuknya. Contoh yang sudah dibahas, yaitu trim lalu parse lalu perkalian, adalah bentuk paling umum: masukan mentah tidak dibutuhkan lagi setelah dibersihkan.
Shadowing kurang cocok dipakai saat nilai lama masih dibutuhkan bersama nilai baru. Kalau 2 nilai harus dibandingkan, beri nama yang berbeda seperti harga_asli dan harga_diskon, karena nama yang sama akan menyembunyikan nilai pertama dan memaksa pembaca menelusuri urutan baris.
Batasan lain adalah jarak. Shadowing yang dipisahkan 30 baris membuat pembaca sulit tahu binding mana yang sedang dipakai. Simpan rantai shadowing dalam 1 bagian pendek, dan hentikan rantainya saat nilai itu mulai dipakai untuk hal lain.
Latihan
- Ubah
shadow_dasar.rssupaya nilai terakhir dicetak sebagai teks memakaiformat!, lalu jelaskan tipenilaidi setiap baris. - Tambahkan 1 blok di dalam
scope_shadow.rsyang membayanginama2 kali, lalu pastikan cetakan terakhir tetapluar. - Ganti
let mut totalpadabekukan.rsmenjadilet totaldan catat pesan kesalahan yang muncul. - Buat rantai shadowing yang mengubah
" 1,5 "menjadif64bernilai 1.5 memakaitrim,replace(',', "."), danparse.
Ringkasan
Shadowing adalah deklarasi let baru dengan nama yang sudah dipakai, dan binding lama berhenti terlihat sampai bloknya selesai. Karena binding-nya baru, tipe boleh berubah dan nilai lama tidak bisa ditimpa tanpa let baru, berbeda dari mut yang memberi izin tulis pada 1 binding dengan 1 tipe. Shadowing di blok dalam tidak mengubah binding di blok luar, dan kompilator menandai binding lama yang tidak pernah terbaca lewat unused_variables. 2 kesalahan yang sering muncul adalah E0308 saat nama yang sudah berganti tipe dipakai dengan tipe lama, dan E0384 saat binding hasil shadowing dicoba ditimpa tanpa mut.
Referensi
- The Rust Programming Language. Variables and Mutability.
- The Rust Reference. Scopes.
- Rust By Example. Scope and Shadowing.