Memahami Sifat dan Masa Hidup Karat
Table of content:
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.
Baca Juga:
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.
trait MyTrait {
fn my_method(&self);
}
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.
struct Person {
name: String,
age: u32,
}impl Info for Person {
fn summary(&self) {
println!("My name is {} and I am {} years old.", self.name, self.age);
}
}
Itu Orang mengimplementasikan struct Infodan Anda dapat memanggil ringkasan metode pada contoh dari Orang struct.
fn main(){
let john = Person { name: String::from("John"), age: 30 };
john.summary();
}
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:
enum MyEnum {
VariantA,
VariantB,
}impl Info for MyEnum {
fn summary(&self) {
match self {
MyEnum::VariantA => {
}
MyEnum::VariantB => {
}
}
}
}
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.
fn do_something<T: Info>(value: T) {
value.summary();
}
Itu
Seumur hidup di Rust
Alat pemeriksa pinjaman Rust menganalisis program dan memastikan penggunaan memori yang tepat. Di Rust, setiap nilai memiliki pemilik yang bertanggung jawab untuk membatalkan alokasi nilai. Ketika variabel meminjam nilai, mereka meminjam referensi ke nilai yang diteruskan, tetapi pemiliknya 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:
func<'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.
fn do_something<'a>(x: &'a i32) -> &'a i32 {
x
}fn main() {
let x = 42;
let result = do_something(&x);
println!("The result is: {}", result);
}
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 Masukan
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.
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() { x } else { 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.
fn first_word<'a>(s: &'a str) -> &'a str {
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.
fn longest<'a>(x: &'a str, y: &str) -> &'a str {
if x.len() > y.len() { x } else { 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.
trait ToString {
fn to_string(&self) -> String;
}fn to_string<'a, T: ToString>(t: &'a T) -> String {
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.
Artikel Terkait
