Learn Rust Coding · Pelajaran

Mutabilitas Internal: RefCell, Cell

Pelajari `RefCell` dan `Cell` untuk mutabilitas internal, yang memungkinkan akses mutabel ke data melalui referensi imutabel secara aman.

Mutabilitas Internal: RefCell, Cell adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 2 dari 3. 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 3 pelajaran total.

Apa Itu Mutabilitas Internal?

Di Rust, aturan peminjaman biasanya mencegah Anda memiliki referensi yang dapat diubah ke data jika Anda sudah memiliki referensi yang tidak dapat diubah ke data tersebut. Hal ini menjamin keamanan data.

Mutabilitas internal adalah pola desain yang memungkinkan Anda mengubah data meskipun Anda hanya memiliki referensi yang tidak dapat diubah ke data tersebut. Ini seperti pengecualian terkontrol terhadap aturan Rust yang biasa, dan digunakan dalam situasi tertentu.

`Cell<T>`: Untuk Tipe Copy

Tipe Cell<T> menyediakan mutabilitas internal untuk tipe yang mengimplementasikan sifat Copy (seperti bilangan bulat, nilai boolean, dan karakter). Tipe ini bekerja dengan mengganti nilai yang ada di dalamnya.

get(): Mengembalikan salinan nilai di dalam Cell.
set(value): Mengganti nilai di dalam Cell dengan nilai baru.

Fitur ini sederhana dan efisien untuk data kecil yang dapat disalin.

Menggunakan `Cell` untuk Memperbarui Nilai

Berikut contoh dasar Cell. Perhatikan bahwa kita dapat mengubah nilai di dalam Cell meskipun Cell itu sendiri dideklarasikan sebagai tidak dapat diubah.

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 Tipe Non-Copy

Jika Anda memerlukan mutabilitas interior untuk tipe yang tidak mengimplementasikan Copy (seperti String, Vec, atau struktur khusus), gunakan RefCell<T>.

RefCell memungkinkan Anda mendapatkan referensi yang dapat diubah ke data di dalamnya, tetapi menerapkan aturan peminjaman Rust saat runtime, bukan saat kompilasi.

Peminjaman Runtime oleh `RefCell`

RefCell menyediakan metode yang mengembalikan penunjuk pintar:

borrow(): Mengembalikan Ref (penunjuk pintar yang tidak dapat diubah). Anda dapat memiliki beberapa peminjaman yang tidak dapat diubah secara bersamaan.
borrow_mut(): Mengembalikan RefMut (penunjuk pintar yang dapat diubah). Anda hanya dapat memiliki satu peminjaman yang dapat diubah dalam satu waktu.

Jika Anda melanggar aturan ini saat runtime, program Anda akan menjalankan panic!.

Menggunakan `RefCell` (Peminjaman yang Tidak Dapat Diubah)

Di sini, kita menggunakan borrow() untuk mendapatkan referensi yang tidak dapat diubah ke String di dalam RefCell. Kita dapat mencetak isinya.

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 yang Dapat Diubah)

Sekarang, mari kita mendapatkan referensi yang dapat diubah menggunakan borrow_mut(). Ini memungkinkan kita mengubah String. Perhatikan bahwa setelah s_mut berada dalam cakupan, tidak ada peminjaman lain (yang dapat diubah maupun yang tidak dapat diubah) yang diizinkan.

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);
}

Kepanikan Runtime `RefCell`

Jika Anda mencoba mendapatkan peminjaman yang dapat diubah saat peminjaman lain yang dapat diubah (atau peminjaman apa pun yang tidak dapat diubah) sedang aktif, RefCell akan menyebabkan program Anda menjalankan panic! saat runtime. Ini mencegah kerusakan data.

Jalankan kode ini untuk melihatnya secara langsung! Kode ini akan berhenti dengan galat "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` vs. `RefCell`

Pemilihan antara Cell dan RefCell bergantung pada tipe data Anda dan cara Anda perlu berinteraksi dengannya:

Cell<T>: Gunakan untuk tipe yang mengimplementasikan Copy. Tipe ini mengganti seluruh nilai dan umumnya lebih sederhana serta lebih efisien.
RefCell<T>: Gunakan untuk tipe yang tidak mengimplementasikan Copy. Tipe ini menyediakan referensi ke data di dalamnya dan menerapkan aturan peminjaman saat runtime, sehingga memungkinkan perubahan yang lebih kompleks.

Pemeriksaan Cepat: `Cell` atau `RefCell`?

Anda memiliki sebuah struct yang perlu menyimpan penghitung yang dapat diubah (u32) dan daftar nama yang dapat diubah (Vec<String>), dan keduanya perlu diperbarui melalui referensi yang tidak dapat diubah ke struct tersebut. Tipe mutabilitas interior apa yang akan Anda gunakan untuk setiap bidang?

Rangkuman: Mutabilitas Interior

Anda telah mempelajari pola mutabilitas interior Rust, yang memungkinkan perubahan data melalui referensi yang tidak dapat diubah dengan cara yang terkendali dan aman.

Cell<T>: Untuk tipe Copy, mengganti nilai di dalamnya.
RefCell<T>: Untuk tipe non-Copy, menyediakan referensi yang dapat diubah maupun yang tidak dapat diubah dengan pemeriksaan saat runtime.
Melanggar aturan RefCell menyebabkan kepanikan saat runtime, sehingga memastikan keamanan.

Tipe-tipe ini penting untuk pola seperti objek tiruan, referensi melingkar, atau saat referensi bersama yang tidak dapat diubah perlu melacak keadaan internal.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mutabilitas Internal: RefCell, Cell” gratis?

Ya — teks lengkap “Mutabilitas Internal: RefCell, Cell” 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 3 pelajaran total.

Apa yang akan aku pelajari di “Mutabilitas Internal: RefCell, Cell”?

Pelajari `RefCell` dan `Cell` untuk mutabilitas internal, yang memungkinkan akses mutabel ke data melalui referensi imutabel secara aman. 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 2 dari 3.

Berapa lama pelajaran “Mutabilitas Internal: RefCell, Cell” 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.

Semua pelajaran dalam kursus ini

Penunjuk Cerdas Box, Rc, dan Arc
Mutabilitas Internal: RefCell, Cell
Konkurensi Tanpa Rasa Takut dengan Thread

← Kembali ke Learn Rust Coding