Fungsi Generik
Parametrikan tingkah laku mengikut jenis.
Fungsi Generik 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.
Mengapa Fungsi Generik
Fungsi generik membolehkan anda menulis satu fungsi yang berfungsi dengan banyak jenis, bukannya menyalin kod untuk setiap jenis. Rust menggantikan jenis ruang letak itu pada masa kompilasi.
Bayangkan anda menulis satu largest untuk integer dan satu lagi untuk chars. Generik menggabungkan kedua-duanya menjadi satu takrifan tanpa kos semasa masa jalan.
Parameter Jenis
Fungsi generik mengisytiharkan parameter jenis dalam kurungan bersudut selepas nama fungsi. Nama T ialah konvensyen, tetapi apa-apa pengecam CamelCase boleh digunakan.
Parameter itu kemudiannya boleh muncul dalam argumen dan jenis pulangan, sebagai pengganti bagi apa-apa jenis konkrit yang digunakan oleh pemanggil.
fn first<T>(pair: (T, T)) -> T {
pair.0
}Fungsi Identiti Ringkas
Atur cara ini mentakrifkan echo generik yang mengembalikan argumennya tanpa perubahan. Ia dipanggil sekali dengan integer dan sekali dengan kepingan rentetan.
Pengkompil menjana versi konkrit yang berasingan untuk setiap jenis yang benar-benar digunakan.
fn echo<T>(value: T) -> T {
value
}
fn main() {
println!("{}", echo(42));
println!("{}", echo("hi"));
}Monomorfisasi
Rust menggunakan monomorfisasi: pada masa kompilasi, Rust menghasilkan salinan fungsi yang dikhususkan untuk setiap jenis konkrit yang digunakan. Tiada pembungkusan atau penghantaran maya.
Hasilnya ialah kod generik yang berjalan sepantas kod khusus jenis yang ditulis secara manual.
Generik Memerlukan Kekangan
Dalam fungsi generik, anda hanya boleh menggunakan operasi yang disokong oleh setiap jenis yang mungkin. T tanpa kekangan tidak boleh dijumlahkan, dibandingkan atau dicetak.
Kod ini gagal dikompil kerana T mungkin tidak melaksanakan perbandingan. Kita akan membaikinya dengan kekangan trait selepas ini.
fn larger<T>(a: T, b: T) -> T {
if a > b { a } else { b }
}Menambah Kekangan Trait
Untuk membandingkan nilai, kita mengehadkan T dengan PartialOrd. Kekangan ini menjamin bahawa jenis tersebut menyokong operator >.
Kita juga menambah Copy supaya nilai boleh dikembalikan tanpa masalah pemindahan bagi jenis mudah seperti integer.
fn larger<T: PartialOrd + Copy>(a: T, b: T) -> T {
if a > b { a } else { b }
}Memanggil Fungsi Berkekangan
Sekarang fungsi ini berfungsi untuk apa-apa jenis yang melaksanakan kedua-dua trait. Integer dan nombor titik apungan kedua-duanya memenuhi PartialOrd + Copy.
Kod sumber yang sama, dimonomorfisasi menjadi dua versi, mencetak keputusan bagi setiap panggilan.
fn larger<T: PartialOrd + Copy>(a: T, b: T) -> T {
if a > b { a } else { b }
}
fn main() {
println!("{}", larger(3, 9));
println!("{}", larger(2.5, 1.0));
}Berbilang Parameter Jenis
Satu fungsi boleh mengisytiharkan beberapa parameter jenis. Setiap parameter adalah berasingan, jadi kedua-dua argumen boleh mempunyai jenis yang berbeza.
Di sini pair menerima apa-apa T dan apa-apa U, kemudian mengembalikannya sebagai tupel.
fn pair<T, U>(a: T, b: U) -> (T, U) {
(a, b)
}Mencetak Nilai Generik
Untuk mencetak nilai generik dengan {}, jenis tersebut mesti melaksanakan Display. Kita menambah kekangan itu supaya apa-apa jenis yang boleh dicetak boleh dihantar.
Contoh ini melabelkan sesuatu nilai dan mengembalikannya, lalu menunjukkan kekangan yang digunakan semata-mata untuk pemformatan.
use std::fmt::Display;
fn announce<T: Display>(label: &str, value: T) {
println!("{}: {}", label, value);
}
fn main() {
announce("count", 7);
announce("name", "Ada");
}Sintaks Turbofish
Kadang-kadang pengkompil tidak dapat membuat kesimpulan tentang T daripada argumen sahaja. Turbofish ::<Type> membolehkan anda menentukannya secara jelas di tempat panggilan.
Ia paling biasa digunakan dengan kaedah seperti parse dan collect apabila jenis pulangan tidak jelas.
fn main() {
let n = "42".parse::<i32>().unwrap();
println!("{}", n + 1);
}Generik untuk Rujukan
Parameter generik juga boleh digunakan dengan rujukan. Mengehadkan melalui rujukan mengelakkan keperluan terhadap Copy apabila anda hanya perlu membaca nilai.
Pembantu bergaya longest_str ini meminjam dua kepingan dan mengembalikan salah satunya tanpa mengambil pemilikan.
fn pick<'a, T: PartialOrd>(a: &'a T, b: &'a T) -> &'a T {
if a > b { a } else { b }
}Semakan Ringkas
Uji pemahaman anda tentang fungsi generik dalam Rust.
Imbas Kembali
Fungsi generik menggunakan parameter jenis dalam kurungan bersudut untuk berfungsi merentas banyak jenis tanpa kos masa jalan melalui monomorfisasi.
Operasi pada jenis generik memerlukan kekangan trait seperti PartialOrd, Copy atau Display. Gunakan turbofish apabila inferens tidak dapat menentukan jenis tersebut.
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 “Fungsi Generik” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Fungsi Generik”, 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 “Fungsi Generik”?
Parametrikan tingkah laku mengikut jenis. 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 “Fungsi Generik” 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.