Rust में त्रुटि प्रबंधन: try/catch और भी बहुत कुछ — पूर्ण गाइड

परिचय: Rust try/catch का उपयोग क्यों नहीं करता?

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

इस लेख में हम चर्चा करेंगे:

• Rust ने try/catch को क्यों छोड़ा;
• मुख्य उपकरण कैसे काम करते हैं: Option, Result, unwrap(), expect();
• ? (प्रश्नवाचक चिह्न) ऑपरेटर क्या है;
• panic! और try! मैक्रो (पुराना) का उपयोग कब करें;
• Rust 2024 में त्रुटि प्रबंधन की आधुनिक प्रथाएँ।

1. मूल बातें: Option और Result — दो मुख्य प्रकार

Option प्रकार: जब मान अनुपस्थित हो सकता है

Option<T> एक एनुम (enum) है जो या तो मान (Some(T)) या उसकी अनुपस्थिति (None) को दर्शाता है। यह उन स्थितियों के लिए आदर्श है जहाँ शास्त्रीय अर्थों में कोई त्रुटि नहीं होती, लेकिन परिणाम खाली हो सकता है।

fn find_user(id: u32) -> Option<String> {    let db = vec!["Alice".to_string(), "Bob".to_string()];    if id < db.len() {        Some(db[id].clone())    } else {        None    }}

fn main() {    match find_user(1) {        Some(name) => println!("मिला: {}", name),        None => println!("उपयोगकर्ता नहीं मिला"),    }}

Result प्रकार: सफलता या त्रुटि

Result<T, E> त्रुटि प्रबंधन के लिए मुख्य उपकरण है। यह भी एक enum है: Ok(T) (सफलता) या Err(E) (त्रुटि)।

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

fn read_file(path: &str) -> Result<String, std::io::Error> {    let mut file = File::open(path)?;    let mut content = String::new();    file.read_to_string(&mut content)?;    Ok(content)}

2. ? ऑपरेटर (प्रश्नवाचक चिह्न) — try/catch का विकल्प

? ऑपरेटर Rust में त्रुटियों को ऊपर भेजने का मुख्य तरीका है। यह भारी-भरकम match संरचनाओं को बदलता है और कोड को साफ बनाता है। यदि परिणाम Ok है, तो मान निकाला जाता है और वेरिएबल को असाइन किया जाता है। यदि Err है, तो फ़ंक्शन तुरंत उस त्रुटि को लौटा देता है।

use std::fs;use std::io;

fn copy_file(source: &str, destination: &str) -> io::Result<()> {    let data = fs::read(source)?; // यदि त्रुटि — बाहर निकलें    fs::write(destination, &data)?;  // यदि त्रुटि — बाहर निकलें    Ok(())}

fn main() -> io::Result<()> {    copy_file("source.txt", "dest.txt")?;    println!("फ़ाइल सफलतापूर्वक कॉपी हुई");    Ok(())}

महत्वपूर्ण: ? ऑपरेटर केवल उन फ़ंक्शन में काम करता है जो Result, Option या FromResidual ट्रेट को लागू करने वाले प्रकार लौटाते हैं।

3. panic!, unwrap और expect — जब त्रुटि घातक हो

panic! मैक्रो

panic!() प्रोग्राम को आपातकालीन रूप से समाप्त करता है (stack unwinding)। इसका उपयोग केवल उन स्थितियों में किया जाता है जहाँ निष्पादन जारी रखना असंभव या अर्थहीन हो: प्रोग्राम लॉजिक में त्रुटियाँ, इनवेरिएंट का उल्लंघन, परीक्षण।

fn divide(a: i32, b: i32) -> i32 {    if b == 0 {        panic!("शून्य से भाग!");    }    a / b}

unwrap() और expect() विधियाँ

unwrap() Option या Result से मान प्राप्त करने का एक त्वरित तरीका है। यदि अंदर None या Err है — तो प्रोग्राम क्रैश हो जाता है। expect() समान है, लेकिन आपको एक कस्टम त्रुटि संदेश निर्दिष्ट करने की अनुमति देता है।