त्रुटि प्रबंधन और ? संचालिका

रस्ट का दर्शन आपको त्रुटियों की संभावना को स्पष्ट रूप से पहचानने और प्रोग्राम संकलित होने से पहले उन्हें संभालने के लिए अपने कोड की संरचना करने के लिए प्रोत्साहित करता है।

रस्ट में त्रुटियों को दो मुख्य श्रेणियों में विभाजित किया गया है: अपूरणीय त्रुटियाँ (जो panic! मैक्रो के माध्यम से तत्काल समाप्ति का कारण बनती हैं) और पुनर्प्राप्ति योग्य त्रुटियाँ (Result<T, E> प्रकार का उपयोग करके प्रबंधित)।

परिणाम<टी, ई> प्रकार और पैटर्न मिलान

अधिकांश पुनर्प्राप्ति योग्य त्रुटियाँ Result<T, E> प्रकार लौटाती हैं, जो एक एनम है जिसे इस प्रकार परिभाषित किया गया है:

enum Result<T, E> {
    Ok(T),
    Err(E),
}

हम परिणाम का निरीक्षण करने के लिए पैटर्न मिलान का उपयोग कर सकते हैं:

use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => panic!("Problem opening the file: {:?}", error),
    };
}

? ऑपरेटर के साथ त्रुटि प्रसार

किसी फ़ंक्शन को कार्यान्वित करते समय, सीधे उसके अंदर त्रुटि को संभालने के बजाय, हम अक्सर कॉलर को त्रुटि वापस करना चाहते हैं ताकि वे तय कर सकें कि क्या करना है। इस प्रक्रिया को त्रुटि प्रसार कहा जाता है।

रस्ट त्रुटियों को फैलाने के लिए सिंटैक्टिक शॉर्टकट के रूप में ? ऑपरेटर प्रदान करता है। यदि Result का मान Ok है, तो Ok का आंतरिक मान अभिव्यक्ति द्वारा लौटाया जाता है; यदि यह Err है, तो Err त्रुटि संपूर्ण वर्तमान फ़ंक्शन से लौटा दी जाती है जैसे कि हमने return Err(...) का उपयोग किया हो।

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username_file = File::open("username.txt")?;
    let mut username = String::new();
    username_file.read_to_string(&mut username)?;
    Ok(username)
}

[!महत्वपूर्ण] ? ऑपरेटर का उपयोग केवल उन फ़ंक्शंस में किया जा सकता है जो उस मान के साथ संगत प्रकार लौटाते हैं जिस पर इसे लागू किया जाता है (आमतौर पर Result, Option, या FromResidual को लागू करने वाले प्रकार)।

कस्टम त्रुटियाँ

हम त्रुटि का मानव-पठनीय प्रतिनिधित्व प्रदान करने के लिए std::fmt::Display विशेषता (और वैकल्पिक रूप से std::error::Error) को लागू करके अपने स्वयं के कस्टम त्रुटि प्रकारों को परिभाषित कर सकते हैं:

use std::fmt;

#[derive(Debug)]
struct MyError {
    details: String,
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Error: {}", self.details)
    }
}

impl std::error::Error for MyError {}

खुद कोशिश करना

अभ्यास 1: के साथ एक फ़ाइल पढ़ना? ऑपरेटर

अभ्यास 2: किसी संख्या को पार्स करना और दोगुना करना

अभ्यास 3: एक कस्टम त्रुटि को परिभाषित करना