0Pricing
Learn Rust Coding · บทเรียน

การแปลงข้อผิดพลาด

การนำ From ไปใช้งาน

การแปลงข้อผิดพลาด เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

เหตุใดจึงต้องแปลงข้อผิดพลาด

โค้ดแต่ละชั้นสร้างชนิดข้อผิดพลาดต่างกัน หากต้องการส่งต่อผ่านฟังก์ชันเดียว คุณต้องแปลงข้อผิดพลาดระดับล่างให้เป็นชนิดเดียวกัน Rust ทำเช่นนี้ผ่านเทรต From

เทรต From

From<T> กำหนดวิธีสร้างชนิดหนึ่งจากอีกชนิดหนึ่ง การนำไปใช้กับชนิดข้อผิดพลาดของคุณจะทำให้สามารถแปลงข้อผิดพลาดต้นทางเป็นชนิดนั้นได้

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

วิธีที่ ? ใช้ From

เมื่อคุณเขียน expr? และชนิดข้อผิดพลาดแตกต่างจากข้อผิดพลาดที่ฟังก์ชันส่งคืน ตัวดำเนินการจะเรียก From::from เพื่อแปลงชนิด นี่คือกลไกเบื้องหลังการส่งต่ออย่างราบรื่น

ชนิดข้อผิดพลาดแบบรวม

กำหนดอีนัมเพื่อเก็บข้อผิดพลาดแต่ละชนิดที่ฟังก์ชันของคุณอาจส่งออกมา

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

นำ From ไปใช้

เขียน impl ของ From สำหรับข้อผิดพลาดต้นทางแต่ละชนิด เพื่อแปลงเป็นตัวเลือกที่ตรงกัน

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

ส่งต่อโดยอัตโนมัติ

เมื่อมี impl เหล่านี้แล้ว ? จะแปลงข้อผิดพลาดแต่ละรายการเป็น AppError ให้โดยอัตโนมัติ

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 คือภาพสะท้อน

การนำ From<A> for B ไปใช้จะมอบ A: Into<B> ให้คุณโดยอัตโนมัติ ควรนำ From ไปใช้ เพราะจะได้ into() มาโดยไม่ต้องเขียนเพิ่ม

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

ห่อออบเจ็กต์ของเทรต

สำหรับการแปลงอย่างรวดเร็ว Box<dyn Error> รองรับชนิดข้อผิดพลาดใด ๆ เนื่องจากไลบรารีมาตรฐานมี impl ของ From แบบครอบคลุมสำหรับแปลงเข้าไปยังชนิดนี้

use std::error::Error;

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

ไลบรารีที่สร้าง From

การเขียน impl ของ From แต่ละรายการด้วยตนเองน่าเบื่อ แอตทริบิวต์ #[from] ของ thiserror จะสร้างให้ และ anyhow จะแปลงทุกอย่างเป็นชนิดเดียวโดยอัตโนมัติ

เลือกแนวทาง

สรุปแนวทางการแปลง:

  • impl ของ From ด้วยตนเอง — ควบคุมได้เต็มที่ แต่มีโค้ดมากขึ้น
  • thiserror #[from] — ข้อผิดพลาดแบบมีชนิด พร้อม impl ที่สร้างให้อัตโนมัติ
  • Box<dyn Error> หรือ anyhow — ขั้นตอนประกอบน้อยที่สุด

เพิ่มบริบทระหว่างการแปลง

impl ของ From ทำได้มากกว่าแค่ห่อข้อผิดพลาด เพราะยังเพิ่มข้อมูลให้ข้อผิดพลาดได้ด้วย ในที่นี้การแปลงจะเพิ่มบริบทเพื่อให้ข้อผิดพลาดสุดท้ายมีข้อมูลมากขึ้น

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

ตรวจสอบอย่างรวดเร็ว

ตัวดำเนินการ ? ใช้เทรตใดในการแปลงชนิดข้อผิดพลาดหนึ่งเป็นอีกชนิดหนึ่ง

สรุปทบทวน

คุณได้เรียนรู้การแปลงข้อผิดพลาด:

  • ? แปลงข้อผิดพลาดผ่านเทรต From
  • นำ From<Source> ไปใช้กับอีนัมข้อผิดพลาดของคุณ
  • From มอบ Into และ into() ให้โดยไม่ต้องเขียนเพิ่ม
  • Box<dyn Error> รองรับข้อผิดพลาดใด ๆ
  • thiserror และ anyhow ช่วยสร้างโค้ดประกอบโดยอัตโนมัติ

คำถามที่พบบ่อย

บทเรียน “การแปลงข้อผิดพลาด” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การแปลงข้อผิดพลาด” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การแปลงข้อผิดพลาด”

การนำ From ไปใช้งาน คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การแปลงข้อผิดพลาด” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. Result และตัวดำเนินการ ?
  2. thiserror
  3. anyhow
  4. การแปลงข้อผิดพลาด
← กลับไปที่ Learn Rust Coding