Shadowing
Mengikat ulang variabel
Shadowing adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.
Apa Itu Shadowing?
Shadowing berarti mendeklarasikan variabel baru dengan nama yang sama seperti variabel sebelumnya. Binding baru tersebut "menutupi" binding lama.
Anda melakukannya dengan menulis ulang let menggunakan nama yang sama.
fn main() {
let x = 5;
let x = x + 1;
let x = x * 2;
println!("x is {}", x);
}Shadowing Bukan Mutasi
Shadowing membuat variabel yang benar-benar baru. Ini berbeda dari mut, yang menggunakan kembali variabel yang sama.
Karena setiap let merupakan binding baru, nilainya bahkan dapat memiliki tipe yang berbeda.
fn main() {
let y = 10; // immutable
let y = y + 5; // new binding, also immutable
println!("y is {}", y);
}Mengubah Tipe dengan Shadowing
Salah satu kegunaan shadowing yang kuat adalah menggunakan kembali nama yang sama sambil mengubah tipenya.
Di sini, sebuah string diuraikan menjadi angka dengan nama yang sama.
fn main() {
let spaces = " ";
let spaces = spaces.len();
println!("count is {}", spaces);
}Mengapa mut Tidak Dapat Mengubah Tipe
Dengan mut, Anda dapat mengubah nilai, tetapi tidak tipenya.
Ini akan gagal dikompilasi:
let mut spaces = " ";spaces = spaces.len();— kesalahan ketidakcocokan tipe.
Shadowing menghindari masalah ini karena membuat variabel baru.
fn main() {
let mut count = 3;
count = 4; // ok, same type
println!("{}", count);
}Shadowing dalam Lingkup Internal
Sebuah variabel dapat ditutupi oleh shadowing di dalam blok internal. Saat blok berakhir, binding dari luar terlihat kembali.
fn main() {
let n = 1;
{
let n = n * 10;
println!("inner {}", n);
}
println!("outer {}", n);
}Mengubah Nilai Selangkah demi Selangkah
Shadowing memungkinkan Anda mengubah nilai melalui beberapa langkah sambil mempertahankan satu nama yang jelas.
fn main() {
let input = "42";
let input: i32 = input.trim().parse().unwrap();
let input = input * 2;
println!("result {}", input);
}Shadowing Mempertahankan Imutabilitas
Setiap binding yang mengalami shadowing tetap immutable. Setelah transformasi, Anda tetap mendapatkan keamanan imutabilitas tanpa perlu membuat nama baru seperti x2 atau x_temp.
fn main() {
let price = 100;
let price = price - 20; // discount applied
let price = price + 5; // shipping added
println!("final price {}", price);
}Shadowing dengan Logika Berbeda
Anda dapat menghitung nilai baru dengan cara apa pun, termasuk menggunakan pemanggilan fungsi atau ekspresi.
fn main() {
let text = "hello";
let text = text.to_uppercase();
println!("{}", text);
}Menghindari Kebingungan
Shadowing memang praktis, tetapi penggunaan berlebihan dapat membingungkan pembaca. Gunakan shadowing saat setiap langkah merupakan transformasi yang jelas dari konsep yang sama, bukan sekadar untuk menggunakan ulang nama secara acak.
fn main() {
let raw = " Rust ";
let raw = raw.trim(); // clean version
println!("[{}]", raw);
}Ringkasan Shadowing vs Penetapan Ulang
Ada dua cara untuk memberikan nilai baru kepada sebuah nama:
- Shadowing:
let x = ...;lagi — variabel baru, dapat mengubah tipe, dan tetap immutable. - Penetapan ulang:
x = ...;denganmut— variabel yang sama, sehingga tipenya harus tetap sama.
fn main() {
let val = "7";
let val: i32 = val.parse().unwrap(); // shadow + type change
let mut val = val;
val += 1; // reassign, same type
println!("{}", val);
}Contoh Praktis
Membaca dan mengonversi data pengguna adalah contoh klasik penggunaan shadowing: pertahankan nama bermakna age sementara tipenya berubah dari teks menjadi angka.
fn main() {
let age = "25";
let age: u32 = age.parse().unwrap();
let age = age + 1; // next birthday
println!("next year you will be {}", age);
}Pemeriksaan Singkat
Tentukan perbedaan antara shadowing dan penggunaan mut.
Ringkasan
Shadowing dalam Rust:
- Tulis ulang
letdengan nama yang sama untuk membuat binding baru. - Binding baru dapat memiliki tipe yang berbeda.
- Setiap nilai yang mengalami shadowing tetap immutable.
- Shadowing berbeda dari
mut, yang memutasi variabel yang sama dan mempertahankan tipenya.
fn main() {
let data = "100";
let data: i32 = data.parse().unwrap();
let data = data / 4;
println!("final {}", data);
}Pertanyaan yang Sering Diajukan
Apakah pelajaran “Shadowing” gratis?
Ya — teks lengkap “Shadowing” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Shadowing”?
Mengikat ulang variabel Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?
Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.
Berapa lama pelajaran “Shadowing” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?
Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.