Belajar Pengaturcaraan Rust · Pelajaran

Kebolehubahan Dalaman: RefCell, Cell

Pelajari `RefCell` dan `Cell` untuk kebolehubahan dalaman, yang membolehkan akses boleh ubah kepada data melalui rujukan tidak boleh ubah, secara selamat.

Pelajaran 2 daripada 311 langkah

Kebolehubahan Dalaman: RefCell, Cell ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 2 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.

Apakah Kebolehubahan Dalaman?

Dalam Rust, peraturan pinjaman biasanya menghalang anda daripada mempunyai rujukan boleh ubah kepada data jika anda sudah mempunyai rujukan tidak boleh ubah kepadanya. Ini memastikan keselamatan data.

Kebolehubahan dalaman ialah corak reka bentuk yang membolehkan anda mengubah data walaupun anda hanya mempunyai rujukan tidak boleh ubah kepadanya. Ia seperti pengecualian terkawal terhadap peraturan biasa Rust, yang digunakan dalam situasi tertentu.

`Cell<T>`: Untuk Jenis Copy

Jenis Cell<T> menyediakan kebolehubahan dalaman untuk jenis yang melaksanakan trait Copy (seperti integer, nilai boolean dan aksara). Ia berfungsi dengan menggantikan nilai di dalamnya.

get(): Mengembalikan salinan nilai di dalam Cell.
set(value): Menggantikan nilai di dalam Cell dengan nilai baharu.

Ia ringkas dan cekap untuk data kecil yang boleh disalin.

Menggunakan `Cell` untuk Mengemas Kini Nilai

Berikut ialah contoh asas Cell. Perhatikan bahawa kita boleh mengubah nilai di dalam Cell walaupun Cell itu sendiri diisytiharkan sebagai tidak boleh ubah.

use std::cell::Cell;

fn main() {
  let my_num = Cell::new(10);
  println!("Initial value: {}", my_num.get());

  my_num.set(20);
  println!("Updated value: {}", my_num.get());

  let x = &my_num;
  x.set(30); // Still works via immutable reference!
  println!("Via immutable ref: {}", my_num.get());
}

`RefCell<T>`: Untuk Jenis Bukan Copy

Apabila anda memerlukan kebolehubahan dalaman untuk jenis yang tidak melaksanakan Copy (seperti String, Vec atau struct tersuai), anda menggunakan RefCell<T>.

RefCell membolehkan anda mendapatkan rujukan boleh ubah kepada data dalaman, tetapi ia menguatkuasakan peraturan peminjaman Rust pada masa jalan, bukan pada masa kompilasi.

Peminjaman Masa Jalan dengan `RefCell`

RefCell menyediakan kaedah yang mengembalikan penuding pintar:

borrow(): Mengembalikan Ref (penuding pintar tidak boleh ubah). Anda boleh mempunyai beberapa peminjaman tidak boleh ubah pada masa yang sama.
borrow_mut(): Mengembalikan RefMut (penuding pintar boleh ubah). Anda hanya boleh mempunyai satu peminjaman boleh ubah pada satu-satu masa.

Jika anda melanggar peraturan ini pada masa jalan, atur cara anda akan melakukan panic!.

Menggunakan `RefCell` (Peminjaman Tidak Boleh Ubah)

Di sini, kami menggunakan borrow() untuk mendapatkan rujukan tidak boleh ubah kepada String di dalam RefCell. Kami boleh mencetak kandungannya.

use std::cell::RefCell;

fn main() {
  let my_string_cell = RefCell::new(String::from("Hello"));

  let s1 = my_string_cell.borrow();
  println!("Value: {}", *s1); // Dereference Ref to get String

  let s2 = my_string_cell.borrow(); // Multiple immutable borrows are fine
  println!("Another value: {}", *s2);
}

Menggunakan `RefCell` (Peminjaman Boleh Ubah)

Sekarang, mari kita dapatkan rujukan boleh ubah menggunakan borrow_mut(). Ini membolehkan kami mengubah suai String. Perhatikan bahawa sebaik sahaja s_mut berada dalam skop, tiada peminjaman lain (boleh ubah atau tidak boleh ubah) dibenarkan.

use std::cell::RefCell;

fn main() {
  let my_string_cell = RefCell::new(String::from("World"));

  { // Scope for the mutable borrow
    let mut s_mut = my_string_cell.borrow_mut();
    s_mut.push_str(", Rust!");
  }
  // s_mut is out of scope here, so we can borrow again

  let s_final = my_string_cell.borrow();
  println!("Final value: {}", *s_final);
}

Panik Masa Jalan `RefCell`

Jika anda cuba mendapatkan peminjaman boleh ubah ketika peminjaman boleh ubah lain (atau sebarang peminjaman tidak boleh ubah) sedang aktif, RefCell akan menyebabkan atur cara anda melakukan panic! pada masa jalan. Ini menghalang kerosakan data.

Jalankan kod ini untuk melihatnya sendiri! Kod ini akan ranap dengan ralat "peminjaman sudah digunakan".

use std::cell::RefCell;

fn main() {
  let my_value = RefCell::new(vec![1, 2, 3]);

  let _first_mut_borrow = my_value.borrow_mut();
  println!("First mutable borrow is active.");

  // This line will cause a runtime panic!
  // Try commenting it out to see the program run successfully.
  let _second_mut_borrow = my_value.borrow_mut();

  println!("This line will not be reached.");
}

Ringkasan `Cell` berbanding `RefCell`

Pemilihan antara Cell dan RefCell bergantung pada jenis data anda dan cara anda perlu berinteraksi dengannya:

Cell<T>: Gunakan untuk jenis yang melaksanakan Copy. Ia menggantikan keseluruhan nilai dan biasanya lebih mudah serta lebih berprestasi.
RefCell<T>: Gunakan untuk jenis yang tidak melaksanakan Copy. Ia menyediakan rujukan kepada data dalaman dan menguatkuasakan peraturan peminjaman pada masa jalan, lalu membolehkan pengubahsuaian yang lebih kompleks.

Semakan Pantas: `Cell` atau `RefCell`?

Anda mempunyai struct yang perlu menyimpan pembilang boleh ubah (u32) dan senarai nama boleh ubah (Vec<String>), dan kedua-duanya perlu dikemas kini melalui rujukan tidak boleh ubah kepada struct tersebut. Jenis kebolehubahan dalaman apakah yang akan anda gunakan untuk setiap medan?

Jawab dalam pelajaran interaktif

Imbas Kembali: Kebolehubahan Dalaman

Anda telah mempelajari corak kebolehubahan dalaman Rust, yang membolehkan data diubah suai melalui rujukan tidak boleh ubah dengan cara yang terkawal dan selamat.

Cell<T>: Untuk jenis Copy, menggantikan nilai dalaman.
RefCell<T>: Untuk jenis bukan Copy, menyediakan rujukan boleh ubah/tidak boleh ubah yang disemak pada masa jalan.
Melanggar peraturan RefCell menyebabkan panik pada masa jalan, sekali gus memastikan keselamatan.

Jenis ini penting untuk corak seperti objek olok-olok, rujukan bulat atau keadaan apabila rujukan tidak boleh ubah yang dikongsi perlu menjejaki keadaan dalaman.

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 “Kebolehubahan Dalaman: RefCell, Cell” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Kebolehubahan Dalaman: RefCell, Cell”, 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 “Kebolehubahan Dalaman: RefCell, Cell”?

Pelajari `RefCell` dan `Cell` untuk kebolehubahan dalaman, yang membolehkan akses boleh ubah kepada data melalui rujukan tidak boleh ubah, secara selamat. 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 2 daripada 3.

Berapa lamakah pelajaran “Kebolehubahan Dalaman: RefCell, Cell” 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

Penuding Pintar Box, Rc dan Arc
Kebolehubahan Dalaman: RefCell, Cell
Keserentakan Tanpa Risau dengan Bebenang

← Kembali ke Belajar Pengaturcaraan Rust