Belajar Pengaturcaraan Rust · Pelajaran

Penukaran Ralat

Pelaksanaan From

Pelajaran 4 daripada 413 langkah

Penukaran Ralat ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 4 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 Menukar Ralat?

Lapisan kod yang berbeza menghasilkan jenis ralat yang berbeza. Untuk menyebarkannya melalui satu fungsi, Anda perlu menukar ralat aras rendah kepada jenis yang seragam. Rust melakukannya melalui trait From.

Trait From

From<T> mentakrifkan cara membina satu jenis daripada jenis yang lain. Melaksanakannya untuk jenis ralat Anda membolehkan Anda menukar ralat sumber kepadanya.

trait From<T> {
    fn from(value: T) -> Self;
}

Cara ? Menggunakan From

Apabila Anda menulis expr? dan jenis ralat berbeza daripada ralat yang dikembalikan oleh fungsi, operator tersebut memanggil From::from untuk menukarnya. Inilah asas penyerapan ralat yang lancar.

Satu Jenis Ralat Seragam

Takrifkan enum untuk menampung setiap jenis ralat yang mungkin dikeluarkan oleh fungsi Anda.

#[derive(Debug)]
enum AppError {
    Io(std::io::Error),
    Parse(std::num::ParseIntError),
}

Melaksanakan From

Tulis impl From bagi setiap ralat sumber supaya ralat tersebut ditukar kepada varian yang sepadan.

impl From<std::io::Error> for AppError {
    fn from(e: std::io::Error) -> Self {
        AppError::Io(e)
    }
}

impl From<std::num::ParseIntError> for AppError {
    fn from(e: std::num::ParseIntError) -> Self {
        AppError::Parse(e)
    }
}

Menyebarkan Secara Automatik

Dengan impl tersebut tersedia, ? menukar setiap ralat kepada AppError secara automatik.

fn read_count(path: &str) -> Result<i32, AppError> {
    let text = std::fs::read_to_string(path)?; // io::Error -> AppError
    let n: i32 = text.trim().parse()?;          // ParseIntError -> AppError
    Ok(n)
}

Into ialah Cerminnya

Melaksanakan From<A> for B secara automatik memberikan Anda A: Into<B>. Utamakan pelaksanaan From; Anda mendapat into() secara percuma.

fn make() -> AppError {
    let e: std::io::Error = std::io::Error::other("boom");
    e.into() // uses From<io::Error> for AppError
}

Membungkus Objek Trait

Untuk penukaran pantas, Box<dyn Error> menerima apa-apa jenis ralat kerana pustaka standard menyediakan impl From umum ke dalamnya.

use std::error::Error;

fn run() -> Result<(), Box<dyn Error>> {
    let n: i32 = "42".parse()?; // ParseIntError -> Box<dyn Error>
    println!("{n}");
    Ok(())
}

Krat yang Menjana From

Menulis setiap impl From secara manual memakan masa. Atribut #[from] dalam thiserror menjana impl tersebut, manakala anyhow menukar semuanya kepada satu jenis secara automatik.

Memilih Pendekatan

Ringkasan strategi penukaran:

Impl From manual — kawalan penuh, lebih banyak kod
thiserror #[from] — ralat berjenis, impl dijana secara automatik
Box<dyn Error> atau anyhow — kod sokongan minimum

Menambah Konteks Semasa Penukaran

Impl From boleh melakukan lebih daripada sekadar membungkus — ia boleh memperkaya ralat. Di sini, penukaran melampirkan konteks tambahan supaya ralat akhir lebih bermaklumat.

impl From<std::num::ParseIntError> for AppError {
    fn from(e: std::num::ParseIntError) -> Self {
        // could log or annotate here before wrapping
        AppError::Parse(e)
    }
}

Semakan Pantas

Trait manakah yang digunakan oleh operator ? untuk menukar satu jenis ralat kepada jenis yang lain?

Jawab dalam pelajaran interaktif

Ringkasan

Anda telah mempelajari penukaran ralat:

? menukar ralat melalui trait From
Laksanakan From<Source> untuk enum ralat Anda
From memberikan Anda Into dan into() secara percuma
Box<dyn Error> menerima apa-apa ralat
thiserror dan anyhow mengautomatikkan kod sokongan

Percuma untuk bermula

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

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Penukaran Ralat” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Penukaran Ralat”, 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 “Penukaran Ralat”?

Pelaksanaan From 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 4 daripada 4.

Berapa lamakah pelajaran “Penukaran Ralat” 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.

Semua pelajaran dalam kursus ini

← Kembali ke Belajar Pengaturcaraan Rust