Rust कोडिंग सीखें · पाठ

त्रुटि रूपांतरण

From इम्प्लीमेंटेशन

पाठ 4, कुल 4 में से13 चरण

त्रुटि रूपांतरण, CoddyKit पर Rust कोडिंग सीखें का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Rust कोडिंग सीखें सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Rust कोडिंग सीखें पाठ्यक्रम में कुल 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 लागू करना

प्रत्येक स्रोत त्रुटि के लिए एक From impl लिखें, ताकि वह संबंधित वैरिएंट में बदल सके।

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 में रखना

त्वरित रूपांतरणों के लिए Box<dyn Error> किसी भी त्रुटि प्रकार को स्वीकार करता है, क्योंकि मानक लाइब्रेरी इसमें बदलने वाले blanket From impl उपलब्ध कराती है।

use std::error::Error;

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

From तैयार करने वाले क्रेट

प्रत्येक From impl को हाथ से लिखना उबाऊ है। thiserror का #[from] एट्रिब्यूट इन्हें तैयार करता है, और anyhow हर चीज़ को स्वचालित रूप से एक प्रकार में बदल देता है।

दृष्टिकोण चुनना

रूपांतरण रणनीतियों का सारांश:

हाथ से लिखे गए From impl — पूरा नियंत्रण, अधिक कोड
thiserror #[from] — प्रकार-सुरक्षित त्रुटियाँ, तैयार किए गए impl
Box<dyn Error> या anyhow — न्यूनतम औपचारिकता

रूपांतरण के दौरान संदर्भ जोड़ना

From impl केवल त्रुटि को लपेटने से अधिक काम कर सकता है — यह त्रुटि को समृद्ध भी कर सकता है। यहाँ रूपांतरण अतिरिक्त संदर्भ जोड़ता है, जिससे अंतिम त्रुटि अधिक जानकारीपूर्ण बनती है।

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 दोहराव वाला कोड स्वचालित करते हैं

शुरुआत निःशुल्क

एआई शिक्षक के साथ Rust सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 39
पाठ: 144

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “त्रुटि रूपांतरण” पाठ निःशुल्क है?

हाँ — Rust कोडिंग सीखें अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “त्रुटि रूपांतरण” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Rust कोडिंग सीखें पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“त्रुटि रूपांतरण” में मैं क्या सीखूँगा?

From इम्प्लीमेंटेशन आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Rust कोडिंग सीखें का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Rust कोडिंग सीखें शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Rust कोडिंग सीखें शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“त्रुटि रूपांतरण” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Rust कोडिंग सीखें पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Rust कोडिंग सीखें पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

Result और ? ऑपरेटर
thiserror
anyhow
त्रुटि रूपांतरण

← Rust कोडिंग सीखें पर वापस जाएँ