Belajar Pengaturcaraan Rust · Pelajaran

Ergonomik Deref dan Wrapper

Jadikan wrapper terasa asli.

Pelajaran 4 daripada 413 langkah

Ergonomik Deref dan Wrapper ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. 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 4 pelajaran.

Masalah Kemudahan Penggunaan

Membungkus jenis dalam newtype meningkatkan keselamatan tetapi mengurangkan kemudahan: tiba-tiba anda perlu menulis wrapper.0.method() di merata-rata tempat dan melaksanakan semula kaedah secara manual.

Trait Deref boleh mengembalikan sebahagian besar kemudahan itu dengan membolehkan wrapper berkelakuan seperti nilai yang dipegangnya.

Perkara yang Dilakukan oleh Deref

Deref menentukan hasil *value dan menggerakkan operator .. Apabila anda memanggil kaedah yang tiada pada wrapper, pengkompil mencubanya semula pada sasaran deref.

Langkah automatik ini dipanggil paksaan deref.

use std::ops::Deref;
struct MyBox<T>(T);
impl<T> Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &T { &self.0 }
}

Paksaan Deref dalam Tindakan

Setelah Deref dilaksanakan, memanggil kaedah dalaman pada wrapper akan berfungsi seperti biasa. Pengkompil menyisipkan .deref() untuk anda sehingga kaedah itu ditemui.

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 Boleh Ubah

Deref hanya memberikan akses dikongsi. Untuk memanggil kaedah yang memerlukan &mut self melalui wrapper, laksanakan juga DerefMut, yang mengembalikan rujukan boleh ubah kepada nilai dalaman.

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

Paksaan pada Sempadan Fungsi

Paksaan deref juga terpakai pada argumen. &Name dipaksa menjadi &String, yang kemudiannya dipaksa menjadi &str, jadi anda boleh menghantar rujukan wrapper terus kepada fungsi yang menjangkakan rujukan dalaman.

fn greet(who: &str) {
    println!("hi {}", who);
}
// greet(&name) works: &Name -> &String -> &str

Contoh Paksaan yang Boleh Dijalankan

Atur cara ini menghantar rujukan wrapper apabila hirisan rentetan dijangka. Rangkaian paksaan deref berlaku secara senyap di tempat panggilan.

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 Salahgunakan Deref

Garis panduan API Rust menasihatkan supaya Deref tidak dilaksanakan untuk jenis yang bukan penuding pintar sebenar. Penggunaan berlebihan menjadikan kaedah yang tersedia pada wrapper tidak dapat dijangka dan mengejutkan pembaca.

Jika newtype wujud untuk mengehadkan API, Deref secara menyeluruh boleh membocorkan tepat kaedah yang ingin anda sembunyikan.

AsRef sebagai Alternatif Bersasar

Apabila anda hanya memerlukan penukaran eksplisit dan bukannya paksaan automatik, laksanakan AsRef. Pemanggil menulis .as_ref() dengan sengaja, yang memastikan permukaan wrapper sendiri kekal jelas.

struct Path(String);
impl AsRef<str> for Path {
    fn as_ref(&self) -> &str { &self.0 }
}

Menghalakan Kaedah Terpilih

Untuk wrapper yang mengehadkan, sebaiknya tulis sendiri hanya kaedah yang ingin anda dedahkan. Ini mengekalkan kawalan penuh terhadap API dan bukannya 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); }
}

Penuding Pintar Menggunakan Deref

Penuding pintar standard seperti Box, Rc dan Arc semuanya melaksanakan Deref. Itulah sebabnya anda boleh memanggil kaedah dalaman padanya secara telus. Inilah penggunaan trait yang sah dan 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 Kemudahan Penggunaan

Pilih berdasarkan tujuan. Gunakan Deref untuk wrapper penuding pintar sebenar, AsRef untuk penukaran pinjaman yang eksplisit dan penghalaan manual apabila newtype mesti mengehadkan API jenis dalaman.

Pilihan yang salah sama ada menyembunyikan terlalu banyak atau membocorkan terlalu banyak.

Semakan Pantas

Tentukan wrapper yang wajar menerima pelaksanaan Deref.

Jawab dalam pelajaran interaktif

Imbas Kembali

Deref dan paksaan deref mengembalikan kemudahan penggunaan kepada wrapper dengan membolehkan operator . dan argumen rujukan diteruskan kepada nilai dalaman; DerefMut menambahkan akses boleh ubah.

Gunakan Deref hanya untuk penuding pintar sebenar. Untuk newtype yang mengehadkan, gunakan AsRef bagi penukaran eksplisit atau halakan hanya kaedah yang anda pilih untuk didedahkan.

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 “Ergonomik Deref dan Wrapper” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Ergonomik Deref dan Wrapper”, 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 4 pelajaran.

Apakah yang akan saya pelajari dalam “Ergonomik Deref dan Wrapper”?

Jadikan wrapper terasa asli. 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 4 daripada 4.

Berapa lamakah pelajaran “Ergonomik Deref dan Wrapper” 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

← Kembali ke Belajar Pengaturcaraan Rust