Belajar Pengaturcaraan Rust · Pelajaran

Pemboleh Ubah, Kebolehubahan dan Pembayangan

Fahami cara mengisytiharkan pemboleh ubah, mengurus kebolehubahan dan menggunakan pembayangan untuk mentakrifkan semula pemboleh ubah dengan fleksibel.

Pelajaran 1 daripada 311 langkah

Pemboleh Ubah, Kebolehubahan dan Pembayangan ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 1 daripada 3. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Pengenalan kepada Pemboleh Ubah Rust

Selamat datang! Dalam Rust, pemboleh ubah ialah asas untuk menyimpan data. Pemboleh ubah ibarat kotak berlabel yang menyimpan maklumat yang diperlukan oleh atur cara anda.

Rust sangat menitikberatkan keselamatan, dan hal ini bermula daripada cara Rust mengendalikan pemboleh ubah. Anda akan mempelajari cara mengisytiharkannya, mengawal kebolehubahannya dan bahkan 'mentakrifkannya semula' dengan cara yang bijak.

Mengisytiharkan Pemboleh Ubah dengan `let`

Untuk mencipta pemboleh ubah dalam Rust, kita menggunakan kata kunci let. Kata kunci ini memberikan nama kepada suatu nilai. Rust sering membuat inferens jenis, jadi anda tidak semestinya perlu menentukannya.

Cuba jalankan contoh mudah ini:

fn main() {
  let apples = 5;
  println!("I have {} apples.", apples);
}

Lalai Tidak Boleh Ubah Rust

Konsep penting dalam Rust ialah pemboleh ubah tidak boleh ubah secara lalai. Selepas anda memberikan nilai kepada pemboleh ubah, anda tidak boleh mengubahnya kemudian.

Hal ini mungkin kelihatan membataskan, tetapi ia membantu mencegah pepijat serta menjadikan kod anda lebih selamat dan mudah difahami, khususnya dalam pengaturcaraan serentak.

Menjadikan Pemboleh Ubah Boleh Ubah dengan `mut`

Jika anda perlu mengubah nilai pemboleh ubah, anda boleh menjadikannya boleh ubah secara jelas dengan menggunakan kata kunci mut sebelum nama pemboleh ubah.

Ini memberitahu Rust dan pembangun lain bahawa nilai pemboleh ubah tersebut memang dimaksudkan untuk diubah.

fn main() {
  let mut score = 100;
  println!("Initial score: {}", score);

  score = 150; // We can change it now!
  println!("New score: {}", score);
}

Bila Hendak Menggunakan `mut`

Walaupun mut berkuasa, amalan yang baik ialah menggunakannya hanya apabila perlu. Utamakan keadaan tidak boleh ubah sebagai lalai anda.

Gunakan mut untuk pembilang, pemboleh ubah keadaan atau nilai yang sememangnya perlu dikemas kini.
Jika nilai tidak pernah berubah selepas diberikan pada awalnya, kekalkan nilai itu sebagai tidak boleh ubah (tanpa mut).
Kejelasan: Menandakan pemboleh ubah sebagai mut secara jelas menjadikan tujuan kod anda lebih mudah difahami.

Mentakrifkan Pemalar dengan `const`

Pemalar ialah jenis khas pemboleh ubah yang tidak boleh ubah. Pemalar diisytiharkan dengan kata kunci const, bukannya let, dan mesti sentiasa mempunyai anotasi jenis yang dinyatakan secara jelas.

Pemalar hanya boleh ditetapkan kepada ungkapan pemalar, bukan hasil panggilan fungsi atau nilai yang hanya boleh dikira semasa masa jalan.

fn main() {
  const MAX_USERS: u32 = 10_000; // Type annotation is required!
  println!("Max users allowed: {}", MAX_USERS);
}

Pemboleh Ubah `let` berbanding Pemalar `const`

Berikut ialah perbezaan utama antara pemboleh ubah let dan pemalar const:

Kebolehubahan: Pemboleh ubah let tidak boleh ubah secara lalai tetapi boleh dijadikan boleh ubah dengan mut. Pemalar const sentiasa tidak boleh ubah.
Pengisytiharan: let menggunakan let. const menggunakan const.
Anotasi Jenis: Pemboleh ubah let selalunya boleh dibuat inferens jenisnya. Pemalar const mesti mempunyai jenis yang dinyatakan.
Skop: Pemalar const boleh diisytiharkan dalam mana-mana skop, termasuk skop global.

Memperkenalkan Pembayangan

Rust membolehkan anda mengisytiharkan pemboleh ubah baharu dengan nama yang sama seperti pemboleh ubah terdahulu. Hal ini dipanggil pembayangan.

Pemboleh ubah baharu 'membayangi' pemboleh ubah lama, bermakna sebarang kod selepas itu akan melihat nilai pemboleh ubah baharu. Pemboleh ubah lama masih wujud dalam memori tetapi tidak lagi boleh dicapai secara terus.

fn main() {
  let x = 5;
  println!("First x: {}", x); // Outputs 5

  let x = x + 1; // 'x' is shadowed by a new 'x'
  println!("Second x: {}", x); // Outputs 6

  { // Inner scope
    let x = x * 2; // 'x' is shadowed again
    println!("Inner x: {}", x); // Outputs 12
  }
  println!("Outer x: {}", x); // Outputs 6 (inner x is out of scope)
}

Pembayangan untuk Penukaran Jenis

Salah satu kegunaan pembayangan yang berkuasa ialah menukar nilai dan malah jenis pemboleh ubah sambil mengekalkan nama yang sama. Ini biasa dilakukan apabila anda perlu menghurai rentetan menjadi nombor.

Daripada mencipta nama pemboleh ubah baharu (contohnya, string_val kemudian num_val), anda boleh menggunakan semula nama yang sama.

fn main() {
  let spaces = "   ";
  println!("Spaces string: '{}'", spaces);

  // Shadow 'spaces' with a new variable that holds its length
  let spaces = spaces.len();
  println!("Spaces count: {}", spaces);
}

Semakan Pantas: Pemboleh Ubah & Kebolehubahan

Pertimbangkan kod Rust berikut. Apakah nilai akhir y yang dicetak pada konsol?

Jawab dalam pelajaran interaktif

Imbas Kembali Pemboleh Ubah, Kebolehubahan & Pembayangan

Syabas! Anda telah mempelajari perkara asas tentang pemboleh ubah dalam Rust:

Gunakan let untuk mengisytiharkan pemboleh ubah yang secara lalainya tidak boleh ubah.
Tambahkan mut untuk menjadikan pemboleh ubah boleh ubah, supaya nilainya boleh berubah.
Gunakan const untuk pemalar, yang sentiasa tidak boleh ubah dan memerlukan anotasi jenis.
Pembayangan membolehkan anda mengisytiharkan pemboleh ubah baharu dengan nama yang sama, lalu menggantikan pemboleh ubah terdahulu. Ini berguna untuk penukaran jenis.

Seterusnya, kita akan mendalami pelbagai jenis data primitif Rust!

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 144

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pemboleh Ubah, Kebolehubahan dan Pembayangan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Pemboleh Ubah, Kebolehubahan dan Pembayangan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Pemboleh Ubah, Kebolehubahan dan Pembayangan”?

Fahami cara mengisytiharkan pemboleh ubah, mengurus kebolehubahan dan menggunakan pembayangan untuk mentakrifkan semula pemboleh ubah dengan fleksibel. Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 3.

Berapa lamakah pelajaran “Pemboleh Ubah, Kebolehubahan dan Pembayangan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Pemboleh Ubah, Kebolehubahan dan Pembayangan
Jenis Data Primitif dan Operator
Fungsi dan Aliran Kawalan

← Kembali ke Belajar Pengaturcaraan Rust