एरर हैंडलिंग में

एरर हैंडलिंग के बारे में

Cairo एरर को संभालने के तरीके देता है। इनकी मदद से समस्याओं को हल किया जा सकता है और एरर को संभाला जा सकता है, जिससे कोड चलाते समय सब कुछ सुचारू रूप से चलता रहता है।

Cairo में एरर दो तरह की होती हैं:

• panic के साथ अनरेकवरेबल एरर - ऐसी एरर प्रोग्राम को तुरंत बंद कर देती हैं।
• Result के साथ रिकवरेबल एरर - ऐसी एरर को रनटाइम के दौरान संभाला जा सकता है।

panic के साथ अनरेकवरेबल एरर

Cairo में प्रोग्राम चलते समय अचानक समस्याएँ आ सकती हैं, जिनसे रनटाइम एरर पैदा होती हैं, जिन्हें "पैनिक" कहते हैं। इससे प्रोग्राम चलना रुक जाता है, और यह उन स्थितियों में मददगार होता है जहाँ आगे बढ़ने का कोई मतलब नहीं होता। पैनिक अनजाने में भी हो सकता है, जब कोई काम कोड को पैनिक करा दे (जैसे ऐरे की सीमा से बाहर का एलिमेंट पढ़ना), और जान-बूझकर भी, panic फंक्शन को कॉल करके।

fn main() {
    let data = array![1, 2];

    if true {
        panic(data);
    }
    println!("This line will not be reached.");
}

इस उदाहरण को चलाने पर कंसोल में यह छपेगा:

Run panicked with [1, 2, ].

एक खास मैक्रो भी है, जिसे panic! कहते हैं, जो किसी ByteArray को एरर मैसेज की तरह इस्तेमाल करने देता है।

panic!("The error for the panic! Error message is not limited to 31 characters anymore");

assert! मैक्रो

assert! मैक्रो आपके कोड में कुछ खास शर्तें लागू करने का उपयोगी टूल है। अगर assert! में दी गई शर्त false निकलती है, तो प्रोग्राम एक ByteArray एरर मैसेज के साथ पैनिक कर जाता है। इसका इस्तेमाल अक्सर डेवलपमेंट के दौरान मान्यताओं को जाँचने और यह पक्का करने के लिए किया जाता है कि वैल्यू कुछ खास मानदंडों पर खरी उतरती हैं।

उदाहरण के लिए:

fn main() {
    let x = 5;
    assert!(x > 0, "x must be greater than zero");
}

अगर x शून्य से बड़ा नहीं है, तो प्रोग्राम "x must be greater than zero" मैसेज के साथ पैनिक कर जाएगा। assert! इनवेरिएंट और प्रीकंडिशन की जाँच करने में मददगार है, बिना हाथ से एरर-हैंडलिंग कोड लिखे।

nopanic नोटेशन

Cairo का nopanic नोटेशन बताता है कि कोई फंक्शन कभी पैनिक नहीं करेगा।

fn function_never_panic() -> felt252 nopanic {
    108
}

किसी nopanic फंक्शन को सिर्फ ऐसे फंक्शन से ही कॉल किया जा सकता है जिस पर भी nopanic लिखा हो।

panic_with एट्रिब्यूट

Cairo का panic_with एट्रिब्यूट ऐसे फंक्शन को चिह्नित करता है जो Option या Result लौटाता है। यह आपके चिह्नित फंक्शन के लिए एक रैपर बनाता है, जो तब पैनिक करेगा जब फंक्शन Option::None या Result::Err लौटाएगा।

#[panic_with('value is 0', wrap_not_zero)]
fn check_not_zero(value: u128) -> Option<u128> {
    if value == 0 {
        Option::None
    } else {
        Option::Some(value)
    }
}

fn main() {
    check_not_zero(0); // -> returns Option::None
    wrap_not_zero(0);  // -> panics with 'value is 0'
}

Result के साथ रिकवरेबल एरर

Result एनम एरर को सहज तरीके से संभालता है और क्रैश होने या अपरिभाषित व्यवहार पैदा करने के बजाय आपको जानकारी देता है।

enum Result<T, E> {
    Ok: T,
    Err: E,
}

चलिए एक उदाहरण देखते हैं, जिसमें हम इस एनम का इस्तेमाल करके शून्य से भाग को संभाल सकते हैं:

fn divide(a: u32, b: u32) -> Result<u32, ByteArray> {
    if b == 0 {
        return Result::Err("Error: Division by zero"); // Return an error if division by zero is attempted
    }
    Result::Ok(a / b)
}

fn main() {
    // Test with division by zero
    match divide(10, 0) {
        Result::Ok(result) => println!("Division successful: {}", result),
        Result::Err(e) => println!("{}", e),
    }
}

? ऑपरेटर

? ऑपरेटर एरर को छोटे और अप्रत्यक्ष तरीके से संभालने के लिए इस्तेमाल होता है, और होने वाली एरर से निपटने का काम कॉल करने वाले फंक्शन पर छोड़ देता है। जब आप Result या Option टाइप पर ? ऑपरेटर का इस्तेमाल करते हैं, तो यह यह करता है:

• अगर वैल्यू Result::Ok(x) या Option::Some(x) है, तो यह अंदर की वैल्यू x सीधे लौटा देता है।
• अगर वैल्यू Result::Err(e) या Option::None है, तो यह फंक्शन से तुरंत लौटकर एरर या None को आगे भेज देता है।

fn parse_u8(s: felt252) -> Result<u8, felt252> {
    match s.try_into() {
        Option::Some(value) => Result::Ok(value),
        Option::None => Result::Err('Invalid integer'),
    }
}

fn do_something_with_parse_u8(input: felt252) -> Result<u8, felt252> {
    let input_to_u8: u8 = parse_u8(input)?;
    // DO SOMETHING
    let res = input_to_u8 - 1;
    Result::Ok(res)
}

fn main() {
    let number: felt252 = 258;
    match do_something_with_parse_u8(number) {
        Result::Ok(value) => println!("Result: {}", value),
        Result::Err(e) => println!("Error: {}", e),
    }
}