Penanganan Kesalahan pada Rust Dengan Berbagai Pendekatan

Kesalahan tidak dapat dihindari dan dapat terjadi karena berbagai alasan, mulai dari input pengguna yang tidak valid hingga kegagalan jaringan, kerusakan perangkat keras, atau bug pemrograman. Penanganan error adalah proses mendeteksi, melaporkan, dan memulihkan dari error tersebut untuk mencegah crash program atau kerusakan data.

Penanganan kesalahan yang efektif sangat penting dalam Rust. Ini memungkinkan Anda membuat aplikasi yang kuat dan andal yang dapat menangani kesalahan dan kegagalan yang tidak terduga. Mekanisme penanganan kesalahan Rust memungkinkan Anda mengembangkan program yang tangguh dan aman yang lebih mudah dipelihara.

Jenis-Jenis Kesalahan dalam Karat

Karat memiliki sistem tipe kaya yang dapat Anda gunakan menangani kesalahan dengan mahir, menurut jenisnya. Manfaat sistem tipe kesalahan Rust yang kaya dibandingkan pendekatan penanganan kesalahan tradisional tidak dapat diremehkan. Sistem tipe kesalahan menyediakan

keamanan jenis yang lebih baik, komposisi, ekspresi, dan kemampuan debug.

Berikut daftar jenis kesalahan umum di Rust:

• Itu std:: io:: Kesalahan type mewakili kesalahan I/O seperti file tidak ditemukan, izin ditolak, atau akhir file tercapai.
• Itu std:: num:: ParseIntError tipe mewakili kesalahan yang terjadi string ke operasi penguraian bilangan bulat.
• Itu std:: opsi:: NoneError type mewakili kesalahan dari membuka Opsi kosong.
• Itu std:: hasil:: Hasil type adalah tipe Hasil generik yang dapat Anda gunakan untuk merepresentasikan kesalahan apa pun.

Setiap jenis kesalahan memiliki seperangkat metode dan sifat sendiri untuk menanganinya dengan cara tertentu.

Berikut adalah contoh penanganan error di Rust untuk operasi pembacaan file:

menggunakan std:: fs:: Berkas;
menggunakan std:: io:: Baca;
fnread_file(jalur: &str) -> Hasil<Rangkaian, std:: io:: Kesalahan> {
membiarkanmut file = File:: buka (jalur)?;
membiarkanmut isi = Rangkaian::baru();
 file.baca_ke_string(&mut isi)?;
Oke(isi)
}

Itu read_file fungsi membaca konten file di jalur yang ditentukan dan mengembalikannya sebagai string. Ia mengembalikan a std:: io:: Kesalahan jika file membuka atau membaca operasi gagal. Itu ? operator menyebarkan kesalahan dan mengembalikan kesalahan sebagai a Hasil.

Mekanisme Penanganan Error pada Rust

Salah satu fitur utama yang berkontribusi pada keamanan Rust adalah mekanisme penanganan kesalahannya. Ada empat mekanisme penanganan kesalahan utama di Rust: itu Hasil jenis, yang Pilihan jenis, yang panik! makro, dan Kesalahan sifat.

Jenis Hasil dan Opsi memungkinkan penanganan kesalahan terstruktur. Anda bisa menggunakan kepanikan! makro untuk menangani kesalahan yang tidak dapat dipulihkan. Ciri Kesalahan memungkinkan Anda menentukan jenis kesalahan khusus dan penanganan kesalahan khusus.

Jenis Hasil

Itu Hasil type adalah tipe bawaan yang mewakili hasil dari operasi yang bisa gagal. Ini memiliki dua varian: the Oke varian, yang mewakili kesuksesan dan mengandung nilai, dan Berbuat salah, yang mewakili kegagalan dan berisi nilai kesalahan.

Inilah cara Anda dapat menggunakan tipe Hasil untuk membuka file dan membaca isinya:

menggunakan std:: fs:: Berkas;
menggunakan std:: io:: pendahuluan::*;
fnread_file(file_path: &str) -> Hasil<Rangkaian, std:: io:: Kesalahan> {
membiarkanmut file = File:: buka (file_path)?;
membiarkanmut isi = Rangkaian::baru();
 file.baca_ke_string(&mut isi)?;
Oke(isi)
}
fnutama() {
membiarkan hasil = file_baca("file.txt");
cocok hasil {
Oke(isi) => cetak!("{}", isi),
Berbuat salah(e) => cetak!("Kesalahan: {}", e),
 }
}

Itu read_file fungsi mengambil jalur file dan mengembalikan a Hasil kesalahan. Jika operasi baca atau buka file gagal, fungsi mengembalikan Berbuat salah nilai. Jika tidak, fungsi mengembalikan Oke nilai. Dalam utama fungsi, yang cocok pernyataan menangani Hasil nilai dan mencetak hasilnya tergantung pada situasi operasi file.

Jenis Opsi

Itu Pilihan type adalah tipe built-in yang mewakili ada atau tidak adanya nilai. Itu Pilihan type memiliki dua varian. Beberapa mewakili nilai, dan Tidak ada menunjukkan tidak adanya nilai.

Inilah cara Anda dapat menggunakan Pilihan type untuk mengambil elemen pertama dari vektor.

fnget_first_elementKlon>(lihat: Vec) -> Pilihan {
jika vec.is_empty() {
Tidak ada
 } kalau tidak {
Beberapa(vec.first().unwrap().clone())
 }
}
fnutama() {
membiarkan vec = vec![1, 2, 3];
membiarkan hasil = get_first_element (vec);
cocok hasil {
Beberapa(elemen) => cetak!("{}", elemen),
Tidak ada => cetak!("Vektornya kosong."),
 }
}

Itu get_first_element fungsi mengembalikan an Pilihan jenis. Jika vektor kosong, fungsi kembali Tidak ada; lain, fungsi kembali Beberapa mengandung elemen pertama dari vektor. Dalam utama fungsi, yang cocok pernyataan menangani Pilihan nilai. Jika Pilihan mengevaluasi ke Beberapa, fungsi mencetak elemen pertama. Jika tidak, fungsi akan mencetak pesan yang menunjukkan bahwa vektor kosong.

Panik! Makro

Itu panik! makro menyediakan fungsionalitas untuk menangani kesalahan yang tidak dapat dipulihkan di Rust. Saat memanggil panik! makro, itu mencetak pesan kesalahan dan menghentikan program.

Berikut adalah contoh penggunaan panik! makro untuk menunjukkan bahwa suatu fungsi memiliki argumen yang tidak valid.

fnmembagi(dividen: f64, pembagi: f64) -> f64 {
jika pembagi == 0.0 {
panik!("Pembagi tidak boleh nol.");
 }
 dividen / pembagi
}
fnutama() {
membiarkan hasil = bagi(4.0, 0.0);
cetak!("{}", hasil);
}

Itu membagi fungsi memeriksa apakah pembaginya nol; jika pembaginya nol, fungsi memanggil panik! makro dengan pesan kesalahan; jika tidak, fungsi menghitung dan mengembalikan hasilnya

Itu utama fungsi memanggil fungsi pembagian dengan argumen yang tidak valid untuk memicu panik! makro.

Inilah pesan kesalahannya:

Sifat Kesalahan

Itu Kesalahan sifat adalah sifat bawaan yang mendefinisikan perilaku jenis kesalahan. Itu Kesalahan sifat menyediakan fungsionalitas untuk menentukan jenis kesalahan khusus dan penanganan kesalahan khusus.

Berikut adalah contoh untuk menentukan jenis kesalahan khusus yang menunjukkan kesalahan file tidak ditemukan.

menggunakan std:: kesalahan:: Kesalahan;
menggunakan std:: fmt;
menggunakan std:: io:: Baca;
#[turunkan (Debug)]
structBerkas tidak ditemukan(Rangkaian);
impl fmt:: Tampilan untuk Berkas tidak ditemukan {
fnfmt(&diri sendiri, F: &mut fmt:: Pemformat) -> fmt::Hasil {
menulis!(F, "Berkas tidak ditemukan: {}", diri sendiri.0)
 }
}
impl Kesalahan untuk Berkas tidak ditemukan {}
fnread_file(file_path: &str) -> Hasil<Rangkaian, Kotak<din Kesalahan>> {
membiarkanmut file = std:: fs:: File:: buka (file_path).map_err(|e| FileNotFound(format!("{}", e)))?;
membiarkanmut isi = Rangkaian::baru();
 file.baca_ke_string(&mut isi)?;
Oke(isi)
}
fnutama() {
membiarkan hasil = file_baca("file.txt");
cocok hasil {
Oke(isi) => cetak!("{}", isi),
Berbuat salah(e) => cetak!("Kesalahan: {}", e),
 }
}

Jenis kesalahan khusus adalah Berkas tidak ditemukan struct. Jenis berisi path file, dan Berkas tidak ditemukan tipe mengimplementasikan Menampilkan sifat untuk mengembalikan pesan kesalahan yang mudah digunakan dan Kesalahan sifat untuk menunjukkan bahwa ini adalah jenis kesalahan.

Dalam read_file fungsi, yang Berkas tidak ditemukan jenis kesalahan mewakili kesalahan file tidak ditemukan, dan map_err metode mengubah kesalahan std:: io:: menjadi kesalahan FileNotFound. Akhirnya, kotak type memungkinkan fungsi untuk mengembalikan semua jenis yang mengimplementasikan sifat Error.

Itu utama fungsi memanggil read_file berfungsi dengan jalur file dan, jika menemukan file, mencetak isinya ke konsol. Jika tidak, pesan kesalahan akan dicetak.

Inilah hasil untuk file yang tidak ada:

Anda Dapat Mengandalkan Model Kepemilikan Rust untuk Keamanan Program

Ditambah dengan mekanisme penanganan kesalahan Rust yang luar biasa, Rust juga menggunakan model kepemilikan yang membantu memastikan program Anda aman dari memori.

Rust memastikan aturan kepemilikan dengan pemeriksa pinjaman pada waktu kompilasi sebelum program Anda berjalan.