Had Trait
Hadkan generik dengan trait.
Had Trait ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 3 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.
Fungsi Kekangan Trait
Kekangan trait mengehadkan jenis generik kepada jenis yang melaksanakan trait tertentu. Kekangan ini memberitahu pengkompil tingkah laku yang dijamin oleh jenis tersebut.
Ini membolehkan kaedah trait digunakan dalam kod generik sambil memastikan fungsi itu boleh digunakan untuk banyak jenis.
Sintaks Kekangan Sebaris
Bentuk paling mudah meletakkan kekangan tepat selepas parameter jenis: T: Trait. Di sini T mesti melaksanakan Display supaya boleh dicetak.
Dalam fungsi tersebut, anda kini boleh memanggil apa-apa kaedah yang disediakan oleh Display.
use std::fmt::Display;
fn show<T: Display>(value: T) {
println!("value = {}", value);
}Trait Tersuai
Kekangan juga berfungsi dengan trait anda sendiri. Takrifkan trait dengan satu kaedah, kemudian hadkan fungsi generik menggunakan trait itu.
Trait Summary ini memerlukan kaedah summarize yang mengembalikan rentetan.
trait Summary {
fn summarize(&self) -> String;
}Melaksanakan dan Mengehadkan
Laksanakan trait untuk sesuatu jenis, kemudian fungsi berkekangan boleh menerima apa-apa jenis yang melaksanakannya. Fungsi itu memanggil kaedah trait tanpa mengetahui jenis konkritnya.
Atur cara lengkap ini mencetak ringkasan sebuah Article.
trait Summary { fn summarize(&self) -> String; }
struct Article { title: String }
impl Summary for Article {
fn summarize(&self) -> String {
format!("Article: {}", self.title)
}
}
fn notify<T: Summary>(item: &T) {
println!("{}", item.summarize());
}
fn main() {
let a = Article { title: String::from("Rust") };
notify(&a);
}Menggabungkan Kekangan dengan +
Wajibkan beberapa trait serentak dengan menggabungkannya menggunakan +. Di sini T mesti melaksanakan kedua-dua Display dan Clone.
Fungsi itu kemudiannya boleh mencetak nilai tersebut dan turut menyalinnya.
use std::fmt::Display;
fn process<T: Display + Clone>(value: T) {
let copy = value.clone();
println!("{}", copy);
}Trait impl dalam Argumen
Sintaks impl Trait pada kedudukan argumen ialah bentuk ringkas bagi kekangan mudah. item: &impl Summary bermaksud perkara yang sama seperti parameter <T: Summary>.
Sintaks ini ringkas untuk kes satu argumen, tetapi memberikan kurang kawalan apabila jenis itu digunakan semula.
trait Summary { fn summarize(&self) -> String; }
fn notify(item: &impl Summary) {
println!("{}", item.summarize());
}Mengembalikan impl Trait
Anda juga boleh mengembalikan impl Trait untuk menyembunyikan jenis konkrit sambil menjanjikan bahawa jenis itu melaksanakan trait tersebut. Ini berguna untuk penutupan dan lelaran.
Pemanggil hanya mengetahui bahawa hasil itu melaksanakan trait yang dinamakan.
fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
move |x| x + n
}
fn main() {
let add5 = make_adder(5);
println!("{}", add5(10));
}Kekangan Membolehkan Operator
Operator dipetakan kepada trait: + memerlukan Add, == memerlukan PartialEq, manakala perbandingan memerlukan PartialOrd. Dengan menetapkan kekangan ini, kod generik boleh menggunakan operator tersebut.
Di sini, operasi penjumlahan memerlukan T melaksanakan Add dengan dirinya sendiri.
use std::ops::Add;
fn sum<T: Add<Output = T>>(a: T, b: T) -> T {
a + b
}Kaedah Lalai Trait
Trait boleh menyediakan badan kaedah lalai. Jenis yang melaksanakannya boleh menggantikan badan tersebut atau menggunakan nilai lalai. Generik yang mempunyai kekangan akan menggunakan versi yang sedang berkuat kuasa.
Summary ini mempunyai summarize lalai yang boleh dikekalkan oleh jenis tanpa perubahan.
trait Summary {
fn summarize(&self) -> String {
String::from("(no summary)")
}
}
struct Note;
impl Summary for Note {}Penghantaran Statik berbanding Dinamik
Kekangan trait menggunakan penghantaran statik: pengkompil memilih kaedah tepat pada masa kompilasi melalui monomorfisasi. Sebaliknya, dyn Trait menggunakan penghantaran dinamik melalui jadual maya.
Kekangan biasanya lebih pantas; dyn menukar sedikit kelajuan dengan fail binari yang lebih kecil dan fleksibiliti semasa masa jalan.
Kekangan pada Struct Generik
Kekangan trait tidak terhad kepada fungsi. Anda boleh mewajibkannya semasa mentakrifkan struct supaya semua tika mematuhi trait tersebut.
Di sini, setiap Sortable<T> menjamin bahawa itemnya boleh dibandingkan.
struct Sortable<T: PartialOrd> {
items: Vec<T>,
}Semakan Pantas
Uji pemahaman anda tentang kekangan trait.
Rumusan
Kekangan trait mengehadkan jenis generik supaya pengkompil membenarkan kaedah dan operator trait tersebut. Gabungkan trait dengan +, dan gunakan impl Trait sebagai bentuk ringkas dalam argumen atau nilai yang dikembalikan.
Kekangan memberikan penghantaran statik tanpa overhed, tidak seperti penghantaran dinamik dyn Trait.
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
Soalan Lazim
Adakah pelajaran “Had Trait” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Had Trait”, 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 “Had Trait”?
Hadkan generik dengan trait. 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 3 daripada 4.
Berapa lamakah pelajaran “Had Trait” 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.