Ergonomi Deref dan Pembungkus
Buat pembungkus terasa seperti tipe asli.
Ergonomi Deref dan Pembungkus 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.
Masalah Kepraktisan
Membungkus tipe dalam newtype meningkatkan keamanan tetapi mengurangi kepraktisan: tiba-tiba Anda harus menulis wrapper.0.method() di mana-mana dan mengimplementasikan ulang metode secara manual.
Trait Deref dapat mengembalikan sebagian besar kepraktisan tersebut dengan membuat pembungkus berperilaku seperti nilai yang disimpannya.
Fungsi Deref
Deref menentukan hasil dari *value dan mengaktifkan operator .. Saat Anda memanggil metode yang tidak dimiliki pembungkus, kompilator mencoba lagi pada target dereferensi.
Langkah otomatis ini disebut koersi dereferensi.
use std::ops::Deref;
struct MyBox<T>(T);
impl<T> Deref for MyBox<T> {
type Target = T;
fn deref(&self) -> &T { &self.0 }
}Koersi Deref dalam Praktik
Setelah Deref diimplementasikan, pemanggilan metode bagian dalam pada pembungkus langsung berfungsi. Kompilator menyisipkan .deref() untuk Anda hingga metode tersebut ditemukan.
use std::ops::Deref;
struct Name(String);
impl Deref for Name {
type Target = String;
fn deref(&self) -> &String { &self.0 }
}
fn main() {
let n = Name("rustacean".to_string());
println!("len = {}", n.len()); // String::len via deref
}DerefMut untuk Akses yang Dapat Diubah
Deref hanya memberikan akses bersama. Untuk memanggil metode yang memerlukan &mut self melalui pembungkus, implementasikan juga DerefMut, yang mengembalikan referensi yang dapat diubah ke nilai bagian dalam.
use std::ops::{Deref, DerefMut};
struct Stack(Vec<i32>);
impl Deref for Stack {
type Target = Vec<i32>;
fn deref(&self) -> &Vec<i32> { &self.0 }
}
impl DerefMut for Stack {
fn deref_mut(&mut self) -> &mut Vec<i32> { &mut self.0 }
}Koersi pada Batas Fungsi
Koersi dereferensi juga berlaku pada argumen. &Name dikoersi menjadi &String, yang kemudian dikoersi menjadi &str, sehingga Anda dapat langsung meneruskan referensi pembungkus ke fungsi yang mengharapkan referensi bagian dalam.
fn greet(who: &str) {
println!("hi {}", who);
}
// greet(&name) works: &Name -> &String -> &strContoh Koersi yang Dapat Dijalankan
Program ini meneruskan referensi pembungkus saat irisan string diharapkan. Rangkaian koersi dereferensi berlangsung secara diam-diam di lokasi pemanggilan.
use std::ops::Deref;
struct Tag(String);
impl Deref for Tag {
type Target = String;
fn deref(&self) -> &String { &self.0 }
}
fn shout(s: &str) { println!("{}!", s.to_uppercase()); }
fn main() {
let t = Tag("ship".to_string());
shout(&t);
}Jangan Menyalahgunakan Deref
Panduan API Rust memperingatkan agar tidak mengimplementasikan Deref untuk tipe yang bukan penunjuk cerdas sejati. Penggunaan yang berlebihan membuat metode yang tersedia pada pembungkus menjadi tidak terduga dan mengejutkan pembaca.
Jika newtype dibuat untuk membatasi API, Deref yang diterapkan secara menyeluruh dapat membocorkan metode yang justru ingin Anda sembunyikan.
AsRef sebagai Alternatif Terarah
Jika Anda hanya memerlukan konversi eksplisit, bukan koersi otomatis, implementasikan AsRef. Pemanggil menulis .as_ref() secara sengaja, sehingga permukaan API milik pembungkus tetap jelas.
struct Path(String);
impl AsRef<str> for Path {
fn as_ref(&self) -> &str { &self.0 }
}Meneruskan Metode Tertentu
Untuk pembungkus yang membatasi, sebaiknya tulis secara manual hanya metode yang ingin Anda tampilkan. Dengan begitu, Anda memiliki kendali penuh atas API dan tidak membocorkan semuanya melalui Deref.
struct Counter(Vec<u8>);
impl Counter {
fn len(&self) -> usize { self.0.len() }
fn push(&mut self, b: u8) { self.0.push(b); }
}Penunjuk Cerdas Menggunakan Deref
Penunjuk cerdas standar seperti Box, Rc, dan Arc semuanya mengimplementasikan Deref. Itulah sebabnya Anda dapat memanggil metode bagian dalam pada penunjuk tersebut secara transparan. Inilah penggunaan trait yang sah dan memang dimaksudkan.
use std::rc::Rc;
fn main() {
let shared = Rc::new(String::from("data"));
// Deref lets us call String methods directly
println!("len = {}", shared.len());
}Memilih Strategi Kepraktisan
Pilih berdasarkan tujuan. Gunakan Deref untuk pembungkus penunjuk cerdas sejati, AsRef untuk konversi pinjaman yang eksplisit, dan penerusan manual ketika newtype harus membatasi API tipe bagian dalamnya.
Pilihan yang salah akan menyembunyikan terlalu banyak atau membocorkan terlalu banyak.
Pemeriksaan Singkat
Tentukan pembungkus mana yang layak mendapatkan implementasi Deref.
Rangkuman
Deref dan koersi dereferensi mengembalikan kepraktisan pada pembungkus dengan membiarkan operator . dan argumen referensi diteruskan ke nilai bagian dalam; DerefMut menambahkan akses yang dapat diubah.
Gunakan Deref hanya untuk penunjuk cerdas sejati. Untuk newtype yang membatasi, gunakan AsRef untuk konversi eksplisit atau teruskan hanya metode yang Anda pilih untuk ditampilkan.
Belajar Rust dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 39
- Pelajaran
- 144
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Ergonomi Deref dan Pembungkus” gratis?
Ya — teks lengkap “Ergonomi Deref dan Pembungkus” 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 “Ergonomi Deref dan Pembungkus”?
Buat pembungkus terasa seperti tipe asli. 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 “Ergonomi Deref dan Pembungkus” 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
- Pola Builder
- Pola Newtype
- Builder Berbasis Keadaan Tipe
- Ergonomi Deref dan Pembungkus