கையாளுவதில் பிழை மற்றும் ? ஆபரேட்டர்

ரஸ்டின் தத்துவம், பிழைகளின் சாத்தியத்தை வெளிப்படையாகக் கண்டறியவும், நிரல் தொகுக்கப்படுவதற்கு முன்பு அவற்றைக் கையாள உங்கள் குறியீட்டை வடிவமைக்கவும் உங்களை ஊக்குவிக்கிறது.

ரஸ்டில் உள்ள பிழைகள் இரண்டு முக்கிய வகைகளாகப் பிரிக்கப்பட்டுள்ளன: மீட்க முடியாத பிழைகள் (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 எனில், 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: தனிப்பயன் பிழையை வரையறுத்தல்