Memahami Sifat dan Masa Hidup Karat

Sifat dan masa hidup adalah komponen utama Rust. Anda dapat menggunakan sifat untuk menentukan perilaku dan kemampuan tipe yang akan diterapkan. Mereka sangat serbaguna, memungkinkan Anda untuk menulis kode yang lebih umum, mengurangi duplikasi, dan meningkatkan pemeliharaan.

Rust menggunakan mekanisme lain—seumur hidup—untuk melacak kepemilikan variabel di dalam dan di luar cakupan. Ini mencegah pointer menggantung selama deallocation variabel.

Bersama-sama, sifat dan masa pakai membantu memastikan keamanan tipe, keamanan memori, dan keandalan kode.

Memahami Sifat-sifat Rust

Ciri-ciri adalah kumpulan metode yang dapat diterapkan oleh tipe lain. Sifatnya mirip dengan antarmuka dalam bahasa seperti Java, Go, dan TypeScript tetapi lebih fleksibel.

Anda akan menggunakan sifat kata kunci untuk mendefinisikan ciri-ciri di Rust, diikuti dengan deklarasi tanda tangan metode.

sifatSifatku {
fnmetode_saya(&diri sendiri);
}

Kode mendefinisikan sifat bernama Sifatku dengan metode_saya metode. Itu &diri sendiri parameter menunjukkan bahwa metode mengacu pada objek dari tipe implementasi sebagai parameter pertamanya.

Setelah menentukan sifat, Anda dapat menerapkannya untuk jenis khusus Anda.

Inilah cara Anda menerapkan sifat untuk tipe struct Anda.

structOrang {
 nama: Rangkaian,
 usia: u32,
}
impl Info untuk Orang {
fnringkasan(&diri sendiri) {
cetak!("Nama saya {} dan umur saya {} tahun.", diri sendiri.nama, diri sendiri.usia);
 }
}

Itu Orang mengimplementasikan struct Info, dan Anda dapat memanggil ringkasan metode pada contoh dari Orang struct.

fnutama(){
membiarkan john = Orang { nama: Rangkaian::dari("Yohanes"), usia: 30 };
 john.ringkasan(); // Keluaran: Nama saya John, dan saya berusia 30 tahun.
}

Itu john variabel adalah turunan dari Orang struct.

Itu utama panggilan fungsi ringkasan yang mencetak pesan ke konsol:

Enum dapat mengimplementasikan sifat. Inilah cara Anda dapat menentukan enum dengan varian yang mengimplementasikan ringkasan metode:

enumMyEnum {
 VarianA,
 VarianB,
}
impl Info untuk MyEnum {
fnringkasan(&diri sendiri) {
cocokdiri sendiri {
 MyEnum:: VarianA => {
// implementasi untuk VarianA
 }
 MyEnum:: VarianB => {
// implementasi untuk VarianB
 }
 }
 }
}

Menggunakan Sifat untuk Parameter Fungsi dan Nilai Pengembalian

Anda dapat menggunakan sifat sebagai parameter fungsi dan mengembalikan nilai. Menggunakan sifat sebagai parameter fungsi berguna untuk menulis kode umum dengan berbagai jenis.

Inilah fungsi yang mengambil parameter dari jenis apa pun yang diimplementasikan Info.

fnlakukan sesuatu(nilai: T) {
 nilai.ringkasan();
}

Itu sintaks menentukan itu T harus menerapkan Info. Anda dapat menghubungi ringkasan fungsi dengan nilai apa pun yang diimplementasikan Info.

Seumur hidup di Rust

Alat pemeriksa pinjaman Rust menganalisis program dan memastikan penggunaan memori yang tepat. Di Karat, setiap nilai memiliki pemilik yang bertanggung jawab untuk membatalkan alokasi nilai. Kapan variabel meminjam nilai, mereka meminjam referensi ke nilai yang diteruskan, tetapi pemilik tetap memiliki kepemilikan.

Seumur hidup adalah cara untuk memastikan bahwa nilai pinjaman digunakan dengan benar. Seumur hidup adalah label yang dilampirkan pada referensi, yang menjelaskan berapa lama referensi tersebut valid.

Di Rust, Anda dapat menentukan seumur hidup menggunakan anotasi apostrof:

fungsi<'A>

Saat membuat referensi, referensi ditetapkan seumur hidup yang menjelaskan berapa lama validitasnya. Jika Anda memiliki fungsi yang mengambil referensi ke sebuah nilai, masa hidup harus lebih lama dari pemanggilan fungsi untuk memastikan bahwa nilai tersebut valid saat fungsi dikembalikan.

Berikut adalah contoh spesifikasi seumur hidup dalam suatu fungsi.

fnlakukan sesuatu<'A>(x: &'Ai32) -> &'Ai32 {
 X
}
fnutama() {
membiarkan x = 42;
membiarkan hasil = lakukan_sesuatu(&x);
cetak!("Hasilnya adalah: {}", hasil);
}

Dalam lakukan sesuatu fungsi, yang 'A parameter seumur hidup menunjukkan bahwa referensi ke X valid selama pemanggilan fungsi. Referensi yang dikembalikan juga valid selama pemanggilan fungsi.

Itu utama fungsi mencetak hasilnya dengan mengirimkan referensi ke X variabel di utama fungsi ke konsol.

Sintaks seumur hidup bisa bertele-tele, tetapi penting untuk keamanan dan manajemen memori. Aturan elision tiga masa pakai memberikan panduan yang memungkinkan Rust menyimpulkan masa pakai referensi dalam situasi tertentu.

Aturan Seumur Hidup Input

Aturan masa pakai input menetapkan bahwa jika suatu fungsi atau metode mengambil satu atau lebih referensi sebagai parameter input, Rust menganggap semua referensi memiliki masa hidup yang sama.

Sederhananya, seumur hidup referensi output akan sama dengan referensi input.

fnterpanjang<'A>(x: &'Astr, y: &'Astr) -> &'Astr {
jika x.len() > y.len() { x } kalau tidak {y}
}

Dalam terpanjang fungsi, Rust menyimpulkan bahwa masa pakai referensi keluaran sama dengan referensi masukan karena keduanya memiliki parameter masa pakai yang sama 'A.

Aturan seumur hidup input membuat penulisan fungsi generik yang menggunakan banyak referensi sebagai input menjadi mudah.

Aturan Seumur Hidup Keluaran

Aturan masa pakai keluaran menetapkan bahwa jika suatu fungsi atau metode mengembalikan referensi, Rust akan berasumsi bahwa masa pakai referensi keluaran berbeda dari masa pakai referensi masukan apa pun.

fnkata pertama<'A>(s: &'Astr) -> &'Astr {
 s.split_whitespace().next().unwrap()
}

Dalam fungsi ini, Rust menyimpulkan bahwa masa pakai referensi keluaran berbeda dengan masa pakai referensi masukan karena split_whitespace() metode membuat referensi output yang tidak mengambil parameter referensi input.

Penghapusan Aturan Seumur Hidup

Elision of lifetimes rule berlaku jika fungsi atau metode mengambil satu referensi atau parameter input dan mengembalikan referensi. Dalam hal ini, Rust mengasumsikan bahwa referensi keluaran memiliki masa pakai yang sama dengan referensi masukan.

fnterpanjang<'A>(x: &'Astr, y: &str) -> &'Astr {
jika x.len() > y.len() { x } kalau tidak {y}
}

Dalam fungsi ini, Rust menyimpulkan bahwa masa pakai referensi keluaran sama dengan masa pakai referensi masukan karena referensi masukan y tidak memiliki parameter seumur hidup. Karat menghilangkan parameter seumur hidup untuk y dan menganggap itu memiliki masa hidup yang sama dengan X.

Aturan ini mempermudah penulisan fungsi yang mengambil satu referensi input dan mengembalikan satu referensi output.

Sifat dan Masa Hidup

Anda dapat menggabungkan sifat dan masa hidup untuk membuat fungsi umum yang berfungsi untuk tipe yang menerapkan sifat dan memiliki masa hidup yang valid.

Inilah sifat dan fungsi yang mereferensikan nilai yang mengimplementasikan sifat tersebut.

sifatToString {
fnto_string(&diri sendiri) -> Rangkaian;
}
fnto_string<'A, T: ToString>(t: &'A T) -> Rangkaian {
 t.to_string()
}

Di sini, parameter seumur hidup 'A memastikan bahwa referensi T berlaku untuk seumur hidup objek yang direferensikan. Anda dapat menggunakan to_string fungsi dengan tipe yang mengimplementasikan ToString sifat yang memiliki masa hidup yang valid.

Ciri-ciri Membentuk Dasar untuk Menerapkan Konsep OOP di Rust

Sifat memungkinkan Anda untuk menentukan perilaku. Meskipun Rust bukan bahasa pemrograman berorientasi objek (OOP), Anda dapat menggunakan sifat untuk mengimplementasikan konsep OOP dari enkapsulasi ke pewarisan, polimorfisme, dan abstraksi.

Menerapkan konsep OOP ini dengan ciri-ciri membuat program Rust Anda dapat diskalakan, kuat, dapat dipelihara, dan efisien.