నమూనా సరిపోలిక, ఎంపిక మరియు ఫలితం

రస్ట్ ప్యాటర్న్ మ్యాచింగ్ అనే అత్యంత శక్తివంతమైన నియంత్రణ ప్రవాహ యంత్రాంగాన్ని కలిగి ఉంది. ఇది నమూనాల శ్రేణితో విలువను సరిపోల్చడానికి మరియు ఏ నమూనా సరిపోలుతుందనే దాని ఆధారంగా కోడ్‌ని అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.

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
}

మీరే ప్రయత్నించండి