లోపం నిర్వహణ మరియు ? ఆపరేటర్

రస్ట్ యొక్క తత్వశాస్త్రం లోపాల సంభావ్యతను స్పష్టంగా గుర్తించమని మరియు ప్రోగ్రామ్ కంపైల్ చేయబడే ముందు వాటిని నిర్వహించడానికి మీ కోడ్‌ను రూపొందించమని మిమ్మల్ని ప్రోత్సహిస్తుంది.

రస్ట్‌లోని ఎర్రర్‌లు రెండు ప్రధాన వర్గాలుగా విభజించబడ్డాయి: ** కోలుకోలేని లోపాలు** (panic! మాక్రో ద్వారా తక్షణ ముగింపుకు కారణమవుతాయి) మరియు ** పునరుద్ధరించదగిన లోపాలు** (Result<T, E> రకాన్ని ఉపయోగించి నిర్వహించబడతాయి).

ఫలితం <T, E> రకం మరియు నమూనా సరిపోలిక

చాలా వరకు తిరిగి పొందగలిగే లోపాలు Result<T, E> రకాన్ని అందిస్తాయి, ఇది ఒక enum ఇలా నిర్వచించబడింది:

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 అయితే, మేము return Err(...)ని ఉపయోగించినట్లుగా మొత్తం ప్రస్తుత ఫంక్షన్ నుండి 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: కస్టమ్ ఎర్రర్‌ను నిర్వచించడం