Rust में त्रुटि प्रबंधन: try/catch और भी बहुत कुछ

परिचय: Rust में त्रुटि प्रबंधन का दर्शन

अपवादों (Java, Python, C++) वाली कई भाषाओं के विपरीत, Rust क्लासिक try/catch संरचना का उपयोग नहीं करता है। इसके बजाय, भाषा एक अधिक स्पष्ट और टाइप-सुरक्षित दृष्टिकोण प्रदान करती है। Rust में त्रुटियाँ नियंत्रण के छिपे हुए प्रवाह नहीं हैं, बल्कि लौटाए गए मान हैं। यह कोड को पूर्वानुमानित बनाता है और 'मूक' विफलताओं से बचाता है।

Rust में त्रुटि स्थितियों को प्रस्तुत करने के लिए दो मुख्य प्रकार हैं:

• Result<T, E> — पुनर्प्राप्त करने योग्य त्रुटियों के लिए (I/O त्रुटियाँ, पार्सिंग त्रुटियाँ, व्यावसायिक तर्क त्रुटियाँ)।
• Option<T> — मान की अनुपस्थिति के लिए (null का एनालॉग, लेकिन सुरक्षित)।

इस लेख में, हम चर्चा करेंगे कि इन प्रकारों के साथ कैसे काम करें, try/catch की दुनिया से उन्हें कैसे बदलें, और Rust में विश्वसनीय कोड कैसे लिखें।

1. Result<T, E>: त्रुटि प्रबंधन का मुख्य उपकरण

Result प्रकार दो वेरिएंट वाला एक enum है: Ok(T) (सफलता) और Err(E) (त्रुटि)। इसका उपयोग अधिकांश फ़ंक्शनों में किया जाता है जो विफल हो सकते हैं।

1.1. Result बनाना और लौटाना

use std::fs::File;use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {    let mut file = File::open(path)?;  // ? ऑपरेटर — try का एनालॉग!    let mut contents = String::new();    file.read_to_string(&mut contents)?;    Ok(contents)}

यहाँ ? ऑपरेटर एक महत्वपूर्ण तत्व है। यह अन्य भाषाओं में try की तरह काम करता है: यदि परिणाम Err है, तो फ़ंक्शन तुरंत उस त्रुटि को लौटा देता है। यदि Ok है, तो यह मान निकालता है।

1.2. match के साथ प्रबंधन

सबसे स्पष्ट तरीका match का उपयोग करना है:

let result = read_file("config.txt");

match result {    Ok(content) => println!("फ़ाइल पढ़ी गई: {}", content),    Err(e) => eprintln!("त्रुटि: {}", e),}

यह try/catch का एक एनालॉग है, लेकिन अधिक लचीला और नियंत्रित है।

1.3. सहायक विधियाँ

• .unwrap() — त्रुटि पर पैनिक करता है (केवल प्रोटोटाइप के लिए)।
• .expect(msg) — कस्टम संदेश के साथ पैनिक करता है।
• .unwrap_or(default) — डिफ़ॉल्ट मान लौटाता है।
• .is_ok() / .is_err() — स्थिति की जाँच करता है।

2. Option<T>: मान की अनुपस्थिति के साथ सुरक्षित कार्य

Option वेरिएंट Some(T) और None वाला एक और enum है। यह null और nullptr को बदलता है, जिससे शून्य पॉइंटर को डीरेफरेंस करने की त्रुटियाँ समाप्त हो जाती हैं।

2.1. उपयोग का उदाहरण

fn find_user(id: u32) -> Option<String> {    if id == 1 {        Some("Alice".to_string())    } else {        None    }}

let user = find_user(2);println!("उपयोगकर्ता: {}", user.unwrap_or("अतिथि".to_string()));

2.2. Result के साथ संयोजन

अक्सर Option को एकसमान प्रबंधन के लिए Result में बदल दिया जाता है:

fn get_user_name(id: u32) -> Result<String, String> {    find_user(id).ok_or("उपयोगकर्ता नहीं मिला".to_string())}

विधि .ok_or() Some को Ok में और None को Err में बदल देती है।

3. ? ऑपरेटर: try/catch का सुरुचिपूर्ण विकल्प

? ऑपरेटर सिंटैक्टिक शुगर है जो स्वचालित रूप से Result या Option को अनपैक करता है। यह केवल उन फ़ंक्शनों में उपलब्ध है जो संबंधित प्रकार लौटाते हैं।

3.1. कॉल की श्रृंखला के साथ उदाहरण

use std::num::ParseIntError;

fn parse_and_add(a: &str, b: &str) -> Result<i32, ParseIntError> {    let x: i32 = a.parse()?;    let y: i32 = b.parse()?;    Ok(x
```