Menentukan Trait
Tingkah laku dikongsi
Menentukan Trait ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 1 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.
Apakah Itu Trait?
Trait mentakrifkan tingkah laku dikongsi — satu set kaedah yang boleh dilaksanakan oleh sesuatu jenis. Ia serupa dengan antara muka dalam bahasa lain.
Trait membolehkan jenis yang berbeza bersetuju pada kontrak yang sama.
Mengisytiharkan Trait
Gunakan kata kunci trait diikuti tandatangan kaedah. Tandatangan tersebut mengisytiharkan perkara yang mesti disediakan oleh pelaksana.
trait Greet {
fn hello(&self) -> String;
}
fn main() {
println!("trait declared");
}Melaksanakan Trait
Gunakan impl TraitName for Type untuk menyediakan kaedah tersebut. Tandatangan mesti sepadan dengan trait secara tepat.
trait Greet {
fn hello(&self) -> String;
}
struct Dog;
impl Greet for Dog {
fn hello(&self) -> String {
String::from("Woof")
}
}
fn main() {
let d = Dog;
println!("{}", d.hello());
}Banyak Jenis, Satu Trait
Berbilang jenis boleh melaksanakan trait yang sama, setiap satunya dengan caranya sendiri. Inilah cara trait menyatukan tingkah laku merentas jenis yang tidak berkaitan.
trait Greet { fn hello(&self) -> String; }
struct Dog;
struct Cat;
impl Greet for Dog { fn hello(&self) -> String { String::from("Woof") } }
impl Greet for Cat { fn hello(&self) -> String { String::from("Meow") } }
fn main() {
println!("{}", Dog.hello());
println!("{}", Cat.hello());
}Trait sebagai Parameter Fungsi
Sintaks impl Trait menerima sebarang jenis yang melaksanakan trait tersebut. Fungsi itu berfungsi secara seragam tanpa mengetahui jenis konkritnya.
trait Greet { fn hello(&self) -> String; }
struct Dog;
impl Greet for Dog { fn hello(&self) -> String { String::from("Woof") } }
fn announce(g: &impl Greet) {
println!("It says: {}", g.hello());
}
fn main() {
announce(&Dog);
}Had Trait pada Generik
Anda boleh mewajibkan jenis generik melaksanakan trait menggunakan had trait. Ini membolehkan kaedah trait digunakan di dalam fungsi.
trait Greet { fn hello(&self) -> String; }
struct Cat;
impl Greet for Cat { fn hello(&self) -> String { String::from("Meow") } }
fn shout<T: Greet>(g: &T) {
println!("{}!", g.hello().to_uppercase());
}
fn main() {
shout(&Cat);
}Berbilang Had Dengan +
Wajibkan beberapa trait serentak dengan +. Di sini, sesuatu nilai mesti melaksanakan trait tersuai dan Clone standard.
trait Named { fn name(&self) -> String; }
#[derive(Clone)]
struct Item { label: String }
impl Named for Item {
fn name(&self) -> String { self.label.clone() }
}
fn describe<T: Named + Clone>(t: &T) {
let copy = t.clone();
println!("named {}", copy.name());
}
fn main() {
describe(&Item { label: String::from("box") });
}Klausa where
Untuk banyak had, klausa where memastikan tandatangan mudah dibaca dengan memindahkan kekangan ke bawahnya.
use std::fmt::Debug;
fn print_all<T>(items: &[T])
where
T: Debug,
{
for it in items {
println!("{:?}", it);
}
}
fn main() {
print_all(&[1, 2, 3]);
}Trait Boleh Mempunyai Beberapa Kaedah
Sesuatu trait boleh mengisytiharkan banyak kaedah. Pelaksana mesti menyediakan semua kaedah yang diperlukan, lalu memberikan jenis itu set tingkah laku yang lengkap.
trait Shape {
fn area(&self) -> f64;
fn name(&self) -> String;
}
struct Square { side: f64 }
impl Shape for Square {
fn area(&self) -> f64 { self.side * self.side }
fn name(&self) -> String { String::from("square") }
}
fn main() {
let s = Square { side: 3.0 };
println!("{} area {}", s.name(), s.area());
}Mengapa Trait Penting
Trait membolehkan polimorfisme tanpa pewarisan. Trait menggerakkan generik, lebihan beban operator (Add), pemformatan (Display) dan sebahagian besar pustaka standard.
Trait ialah teras model abstraksi Rust.
Peraturan Keselarasan
Peraturan anak yatim menyatakan bahawa anda hanya boleh melaksanakan trait untuk sesuatu jenis jika anda memiliki trait atau jenis tersebut. Ini menghalang pelaksanaan yang bercanggah merentas peti.
Semakan Pantas
Uji pemahaman anda tentang trait.
Imbas Kembali
Anda telah mempelajari cara mentakrifkan dan menggunakan trait:
traitmengisytiharkan tingkah laku dikongsiimpl Trait for Typemenyediakan kaedah- Had trait (
T: Trait,+,where) mengehadkan generik - Peraturan anak yatim memastikan pelaksanaan kekal selaras
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 “Menentukan Trait” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Menentukan 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 “Menentukan Trait”?
Tingkah laku dikongsi 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 1 daripada 4.
Berapa lamakah pelajaran “Menentukan 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.