Learn Rust Coding · Pelajaran

Konversi Error

Implementasi From

Konversi Error adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. 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 4 pelajaran total.

Mengapa Mengonversi Error?

Lapisan kode yang berbeda menghasilkan jenis error yang berbeda. Untuk meneruskannya melalui satu fungsi, Anda perlu mengonversi error tingkat rendah menjadi satu jenis yang seragam. Rust melakukannya melalui trait From.

Trait From

From<T> mendefinisikan cara membuat satu jenis dari jenis lainnya. Dengan mengimplementasikannya untuk jenis error Anda, Anda dapat mengonversi error sumber menjadi jenis tersebut.

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

Cara ? Menggunakan From

Saat Anda menulis expr? dan jenis error berbeda dari error yang dikembalikan fungsi, operator tersebut memanggil From::from untuk mengonversinya. Inilah keajaiban di balik penerusan yang mulus.

Satu Jenis Error Terpadu

Definisikan enum untuk menampung setiap jenis error yang mungkin dikeluarkan fungsi Anda.

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

Mengimplementasikan From

Tulis impl From untuk setiap error sumber agar error tersebut dikonversi menjadi varian yang sesuai.

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)
    }
}

Meneruskan Secara Otomatis

Dengan impl tersebut, ? mengonversi setiap error menjadi AppError secara otomatis.

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 Adalah Kebalikannya

Mengimplementasikan From<A> for B secara otomatis memberi Anda A: Into<B>. Sebaiknya implementasikan From; Anda akan mendapatkan into() secara gratis.

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 konversi cepat, Box<dyn Error> menerima jenis error apa pun karena pustaka standar menyediakan impl From umum untuknya.

use std::error::Error;

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

Crate yang Menghasilkan From

Menulis setiap impl From secara manual melelahkan. Atribut #[from] milik thiserror menghasilkannya, sedangkan anyhow secara otomatis mengonversi semuanya menjadi satu jenis.

Memilih Pendekatan

Ringkasan strategi konversi:

Impl From manual — kendali penuh, lebih banyak kode
thiserror #[from] — error bertipe, impl yang dihasilkan otomatis
Box<dyn Error> atau anyhow — lebih sedikit kode pendukung

Menambahkan Konteks Selama Konversi

Impl From dapat melakukan lebih dari sekadar membungkus—impl tersebut juga dapat memperkaya error. Di sini, konversi menambahkan konteks ekstra sehingga error akhir lebih informatif.

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

Pemeriksaan Singkat

Trait apa yang digunakan operator ? untuk mengonversi satu jenis error menjadi jenis lainnya?

Ringkasan

Anda telah mempelajari konversi error:

? mengonversi error melalui trait From
Implementasikan From<Source> untuk enum error Anda
From memberi Anda Into dan into() secara gratis
Box<dyn Error> menerima error apa pun
thiserror dan anyhow mengotomatiskan kode pendukung

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Konversi Error” gratis?

Ya — teks lengkap “Konversi Error” 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 4 pelajaran total.

Apa yang akan aku pelajari di “Konversi Error”?

Implementasi From 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 4 dari 4.

Berapa lama pelajaran “Konversi Error” 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

← Kembali ke Learn Rust Coding