முறை பொருத்தம், விருப்பம் மற்றும் முடிவு

ரஸ்ட் பேட்டர்ன் மேட்சிங் எனப்படும் மிகவும் சக்திவாய்ந்த கட்டுப்பாட்டு ஓட்ட பொறிமுறையைக் கொண்டுள்ளது. ஒரு மதிப்பை தொடர்ச்சியான வடிவங்களுடன் ஒப்பிட்டுப் பார்க்கவும், எந்த வடிவத்துடன் பொருந்துகிறது என்பதன் அடிப்படையில் குறியீட்டை இயக்கவும் இது உங்களை அனுமதிக்கிறது.

match அறிக்கை

ரஸ்டில் உள்ள match அறிக்கை மற்ற மொழிகளில் switch போலவே உள்ளது, ஆனால் மிகவும் சக்திவாய்ந்த மற்றும் பாதுகாப்பானது. பொருத்தம் முழுமையானது என்பதை கம்பைலர் உறுதிசெய்கிறது, அதாவது சாத்தியமான எல்லா நிகழ்வுகளும் கையாளப்பட வேண்டும்:

enum Direction {
    North,
    South,
    East,
    West,
}

let dir = Direction::East;

match dir {
    Direction::North => println!("Andiamo a Nord"),
    Direction::South => println!("Andiamo a Sud"),
    Direction::East => println!("Andiamo a Est"),
    Direction::West => println!("Andiamo a Ovest"),
}

மதிப்பு இல்லாததைக் கையாளுதல்: Option

ரஸ்டுக்கு பூஜ்ய மதிப்பு (null அல்லது nil) என்ற கருத்து இல்லை. அதற்குப் பதிலாக, நிலையான நூலகம் Option<T> எனப்படும் enum ஐ வரையறுக்கிறது:

• Some(T): T வகையின் மதிப்பைக் கொண்டுள்ளது.
• None: மதிப்பு இல்லாததைக் குறிக்கிறது.

let x: Option<i32> = Some(5);
let y: Option<i32> = None;

match x {
    Some(val) => println!("C'e un valore: {}", val),
    None => println!("Nessun valore trovato"),
}

மீட்டெடுக்கக்கூடிய பிழைகளைக் கையாளுதல்: Result

தோல்வியடையக்கூடிய செயல்பாடுகளுக்கு (கோப்பைப் படிப்பது அல்லது ஒரு சரத்தை எண்ணாகப் பாகுபடுத்துவது போன்றவை), ரஸ்ட் இரண்டு வகைகளைக் கொண்ட Result<T, E> enum ஐப் பயன்படுத்துகிறது:

• Ok(T): செயல்பாடு வெற்றியடைந்தது மற்றும் வெற்றி மதிப்பு T.
• Err(E): செயல்பாடு தோல்வியடைந்தது மற்றும் பிழை உள்ளது E.

fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        Err(String::from("Divisione per zero!"))
    } else {
        Ok(numerator / denominator)
    }
}

ரஸ்டின் கம்பைலருக்கு நன்றி, Ok உள்ளே உள்ள மதிப்பை அணுகுவதற்கு முன், Err கேஸைக் கையாள வேண்டிய கட்டாயத்தில் உள்ளீர்கள், இது பல பொதுவான இயக்க நேரப் பிழைகளைத் தடுக்கிறது.

வைல்டு கார்டு பேட்டர்ன் _

அதிக எண்ணிக்கையிலான மாறுபாடுகளைக் கொண்ட தரவு வகைகளுடன் பணிபுரியும் போது (முழு எண்கள் போன்றவை), match இல் அனைத்து நிகழ்வுகளையும் பட்டியலிடுவது சாத்தியமற்றது. வெளிப்படையாக வரையறுக்கப்படாத மீதமுள்ள எல்லா நிகழ்வுகளையும் பிடிக்க _ வைல்டு கார்டு எழுத்தைப் பயன்படுத்தி ரஸ்ட் அனுமதிக்கிறது:

let some_u8 = 3u8;
match some_u8 {
    1 => println!("One"),
    2 => println!("Two"),
    _ => println!("Something else"), // Handles all other values
}

நீங்களே முயற்சி செய்து பாருங்கள்