Menulis Kode Generik dalam Rust
Pelajari cara menulis fungsi dan struktur data yang bekerja dengan berbagai tipe, sehingga kode lebih dapat digunakan kembali tanpa mengorbankan keamanan tipe.
Menulis Kode Generik dalam Rust adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 3. 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 3 pelajaran total.
Mengapa Menulis Kode Generik?
Bayangkan Anda memerlukan fungsi yang menemukan item terbesar dalam sebuah daftar. Bagaimana jika Anda memerlukannya untuk angka, lalu karakter, dan kemudian objek kustom?
Tanpa generik, Anda harus menulis fungsi terpisah untuk setiap jenis, sehingga menghasilkan banyak kode duplikat. Di sinilah generik berperan!
Memperkenalkan Generik
Generik memungkinkan Anda menulis kode yang bekerja dengan banyak jenis tanpa mengulang kode. Generik merupakan cara untuk menulis fungsi atau struktur data yang fleksibel dan dapat digunakan kembali.
Anggaplah generik sebagai cetak biru yang dapat disesuaikan untuk berbagai bahan.
Fungsi Generik Pertama Anda
Untuk membuat fungsi generik, kita mendeklarasikan parameter jenis dalam kurung sudut <> setelah nama fungsi. Nama parameter jenis yang umum adalah T (dari Type).
Fungsi print_anything ini kini dapat mencetak jenis apa pun!
fn print_anything<T>(item: T) {
println!("The item is: {}", item);
}
pub fn main() {
print_anything(5);
print_anything("hello");
print_anything(true);
}Penjelasan Parameter Jenis
<T> dalam fn print_anything<T>(item: T) berarti T adalah pengganti suatu jenis. Saat Anda memanggil fungsi dengan i32, T menjadi i32.
- Parameter Jenis: Jenis generik biasanya diberi nama dengan huruf kapital, seperti
T,U, danV. - Fleksibilitas: Kompilator menentukan jenis konkret saat kompilasi.
Menambahkan Perilaku: Batas Trait
Terkadang, fungsi generik Anda memerlukan parameter jenis T agar memiliki perilaku tertentu. Misalnya, jika Anda ingin membandingkan dua nilai T, T harus dapat dibandingkan.
Kita menambahkan batas trait untuk menentukan persyaratan ini. Di sini, T: PartialOrd + Copy berarti T harus mengimplementasikan trait PartialOrd (pengurutan parsial untuk perbandingan) dan Copy.
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
let mut largest = list[0];
for &item in list.iter() {
if item > largest {
largest = item;
}
}
largest
}
pub fn main() {
let number_list = vec![34, 50, 25, 100, 65];
println!("Largest number: {}", largest(&number_list));
let char_list = vec!['y', 'm', 'a', 'q'];
println!("Largest char: {}", largest(&char_list));
}Sintaks Beberapa Batas Trait
Anda dapat mensyaratkan beberapa trait untuk jenis generik dengan menggunakan sintaks +, seperti T: TraitA + TraitB.
Untuk batas yang kompleks, Anda juga dapat menggunakan klausa where setelah tanda tangan fungsi agar tanda tangan tersebut lebih rapi:
fn some_function<T, U>(t: T, u: U) -> i32 where T: Display + Clone, U: Clone + Debug { /* ... */ }
Struct Generik
Sama seperti fungsi, Anda dapat mendefinisikan struct agar bersifat generik terhadap satu atau beberapa parameter jenis. Dengan demikian, struktur data Anda dapat menyimpan data dari jenis apa pun yang ditentukan.
Struct Point<T> dapat menyimpan koordinat dari jenis T apa pun (misalnya, i32 dan f64).
struct Point<T> {
x: T,
y: T,
}
pub fn main() {
let integer_point = Point {
x: 5,
y: 10
};
let float_point = Point {
x: 1.0,
y: 4.0
};
println!("Int Point: ({}, {})",
integer_point.x, integer_point.y);
println!("Float Point: ({}, {})",
float_point.x, float_point.y);
}Mengimplementasikan Method pada Struct Generik
Saat mengimplementasikan method untuk struct generik, Anda perlu menentukan parameter jenis generik setelah impl.
Anda juga dapat menambahkan batas trait pada method jika method tersebut secara khusus memerlukan perilaku tertentu dari jenis generiknya.
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
pub fn main() {
let p = Point {
x: 5,
y: 10
};
println!("p.x = {}", p.x());
}Generik dan Performa
Salah satu keunggulan Rust adalah generik merupakan abstraksi tanpa biaya. Artinya, penggunaan generik tidak menimbulkan penalti performa saat runtime.
Rust mencapai hal ini melalui monomorfisasi: saat kompilasi, kompilator menghasilkan versi khusus dari kode generik Anda untuk setiap jenis konkret yang digunakan. Jadi, largest<i32> dan largest<char> menjadi dua fungsi berbeda yang telah dioptimalkan.
Uji Pengetahuan Anda
Pernyataan manakah berikut ini yang BENAR tentang generik Rust?
Ringkasan: Kekuatan Generik
Dalam pelajaran ini, Anda telah mempelajari dasar-dasar penulisan kode generik dalam Rust:
- Pengertiannya: Cara untuk menulis kode yang fleksibel dan dapat digunakan kembali.
- Fungsi generik: Menggunakan
<T>untuk parameter jenis. - Batas trait: Menentukan perilaku yang diperlukan dengan
T: Trait. - Struct generik: Membuat struktur data yang menyimpan jenis generik.
- Tanpa biaya: Generik Rust dikompilasi menjadi kode khusus sehingga tidak ada penalti saat runtime.
Generik adalah landasan Rust idiomatis yang memungkinkan abstraksi kuat dan aman terhadap jenis!
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Menulis Kode Generik dalam Rust” gratis?
Ya — teks lengkap “Menulis Kode Generik dalam Rust” 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 3 pelajaran total.
Apa yang akan aku pelajari di “Menulis Kode Generik dalam Rust”?
Pelajari cara menulis fungsi dan struktur data yang bekerja dengan berbagai tipe, sehingga kode lebih dapat digunakan kembali tanpa mengorbankan keamanan tipe. 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 1 dari 3.
Berapa lama pelajaran “Menulis Kode Generik dalam Rust” 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
- Menulis Kode Generik dalam Rust
- Mendefinisikan dan Menerapkan Trait
- Penggunaan Trait Tingkat Lanjut: Tipe Terkait