उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) · पाठ

त्रुटि प्रबंधन और अपवाद

WASM और JavaScript कोड के बीच त्रुटियों और अपवादों को प्रभावी ढंग से आगे भेजने और सँभालने की मजबूत रणनीतियाँ सीखें

पाठ 3, कुल 4 में से12 चरण

त्रुटि प्रबंधन और अपवाद, CoddyKit पर उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

त्रुटि प्रबंधन क्यों महत्वपूर्ण है

जब आपका WebAssembly (WASM) मॉड्यूल JavaScript के साथ इंटरैक्ट करता है, तो कुछ गड़बड़ हो सकती है। संभव है कि कोई गणना विफल हो जाए, इनपुट अमान्य हो या ब्राउज़र API कॉल अपेक्षा के अनुसार काम न करे।

उचित त्रुटि प्रबंधन सुनिश्चित करता है कि आपका एप्लिकेशन स्थिर बना रहे और उपयोगकर्ताओं या डेवलपर को अर्थपूर्ण प्रतिक्रिया दे। इसका उद्देश्य भाषाओं की सीमाओं के पार अप्रत्याशित स्थितियों को सहजता से संभालना है।

WASM होस्ट भाषाओं में त्रुटियाँ

WebAssembly में स्वयं JavaScript या Java जैसी "exceptions" की अवधारणा नहीं होती। इसके बजाय, WASM में कंपाइल की जाने वाली भाषाएँ (जैसे Rust या C++) अक्सर त्रुटियों का संकेत देने के लिए रिटर्न प्रकारों या विशिष्ट डेटा संरचनाओं का उपयोग करती हैं।

Rust: Result<T, E> एनम का उपयोग करता है, जो सफलता के लिए Ok(T) या विफलता के लिए Err(E) हो सकता है।
C/C++: अक्सर रिटर्न मानों (जैसे, त्रुटि के लिए -1) का उपयोग करता है या वैश्विक त्रुटि संकेतक सेट करता है।

हमारा ध्यान इस बात पर है कि भाषा-विशिष्ट त्रुटि पैटर्न WASM-JavaScript सीमा के पार कैसे रूपांतरित होते हैं।

WASM त्रुटियों को JS तक पहुँचाना

लक्ष्य यह है कि आपके WASM मॉड्यूल से उत्पन्न त्रुटियाँ मानक JavaScript Error ऑब्जेक्ट के रूप में दिखाई दें। इससे JavaScript अपने परिचित try...catch तंत्र का उपयोग कर सकता है।

wasm-bindgen जैसे टूल Rust के Result::Err वैरिएंट को JavaScript exceptions में स्वचालित रूप से बदलकर इस अंतर को पाटने में सहायता करते हैं। सहज इंटरऑपरेबिलिटी के लिए यह बहुत महत्वपूर्ण है।

Rust WASM त्रुटि उदाहरण

यह WASM में कंपाइल किया गया एक Rust फ़ंक्शन है, जो त्रुटि लौटा सकता है। Result<i32, JsValue> रिटर्न प्रकार पर ध्यान दें। JsValue ऐसी किसी भी चीज़ के लिए सामान्य प्रकार है, जो JS सीमा के पार जा सकती है।

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn divide_numbers(a: i32, b: i32) -> Result<i32, JsValue> {
    if b == 0 {
        // Return a JavaScript error value
        return Err(JsValue::from_str("Cannot divide by zero!"));
    }
    Ok(a / b)
}
// This is a complete Rust module (lib.rs content).
// Exported functions like divide_numbers are its entry points for JavaScript.

JS में WASM त्रुटियाँ पकड़ना

जब आपका WASM मॉड्यूल कोई त्रुटि आगे पहुँचाता है, तो JavaScript उसे मानक try...catch ब्लॉक का उपयोग करके पकड़ सकता है। पकड़ा गया त्रुटि ऑब्जेक्ट JavaScript Error होगा, जिससे आप उसके संदेश और संभवतः अन्य गुणों की जाँच कर सकते हैं।

इससे WASM त्रुटियों को अपने मौजूदा JavaScript त्रुटि प्रबंधन प्रवाह में एकीकृत करना बहुत सरल और परिचित हो जाता है।

JS द्वारा WASM त्रुटियों का उपयोग

यह JavaScript कोड हमारे WASM मॉड्यूल को लोड करता है और divide_numbers फ़ंक्शन को कॉल करने का प्रयास करता है। देखें कि try...catch ब्लॉक WASM से मिली शून्य से भाग देने की त्रुटि को कैसे संभालता है।

// Assume 'wasm' is the loaded WASM module from Rust
// This is typical for 'wasm-bindgen' projects.

async function runWasmExample() {
  // In a real app, this would load your .wasm and .js glue code
  const wasm = { divide_numbers: (a, b) => {
    if (b === 0) throw new Error("Cannot divide by zero!");
    return a / b;
  }};

  try {
    // This call will succeed
    let result1 = wasm.divide_numbers(10, 2);
    console.log("10 / 2 =", result1); // Output: 5

    // This call will throw an error from WASM (simulated here)
    let result2 = wasm.divide_numbers(10, 0);
    console.log("10 / 0 =", result2); // This line won't be reached
  } catch (e) {
    console.error("Caught WASM error:", e.message);
    // Output: Caught WASM error: Cannot divide by zero!
  }
}

runWasmExample();

WASM कॉलबैक में JS त्रुटियाँ

यदि आपका WASM मॉड्यूल किसी ऐसे JavaScript फ़ंक्शन ("कॉलबैक") को कॉल करे जो फिर त्रुटि उत्पन्न कर दे, तो क्या होगा? WASM इस पर कैसे प्रतिक्रिया देगा?

जब WASM द्वारा बुलाया गया JavaScript फ़ंक्शन त्रुटि उत्पन्न करता है, तो आमतौर पर wasm-bindgen ग्लू कोड उस त्रुटि को पकड़कर JsValue त्रुटि के रूप में WASM की ओर वापस भेज देता है। इसके बाद आपका Rust कोड उसे Rust से उत्पन्न त्रुटियों की तरह Result प्रकार का उपयोग करके संभाल सकता है।

WASM द्वारा JS कॉलबैक त्रुटियाँ संभालना

यह एक Rust फ़ंक्शन है, जो JavaScript कॉलबैक को कॉल करता है। JavaScript कॉलबैक विफल हो सकता है और Rust कोड उस संभावित त्रुटि को संभालता है।

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
extern "C" {
    // Import a JS function that might throw an error
    // The `catch` attribute ensures JS errors are converted to Rust `Result::Err`
    #[wasm_bindgen(catch)]
    fn js_might_fail(value: i32) -> Result<i32, JsValue>;
}

#[wasm_bindgen]
pub fn call_js_and_handle_error(input: i32) -> Result<String, JsValue> {
    match js_might_fail(input) {
        Ok(result) => Ok(format!("JS callback succeeded: {}", result)),
        Err(e) => {
            // Convert JsValue error back to a string for our Rust Result
            let error_msg = e.as_string().unwrap_or_else(|| "Unknown JS error".into());
            Err(JsValue::from_str(&format!("JS callback failed: {}", error_msg)))
        }
    }
}
// This is a complete Rust module (lib.rs content).

स्पष्टता के लिए कस्टम त्रुटि प्रकार

अधिक विशिष्ट त्रुटि प्रबंधन के लिए आप Rust में कस्टम त्रुटि प्रकार परिभाषित कर सकते हैं और उन्हें JavaScript Error प्रकारों में मैप कर सकते हैं। wasm-bindgen आपको यह नियंत्रित करने देता है कि आपकी Rust त्रुटियों को JavaScript में किस रूप में दर्शाया जाए।

इससे JavaScript उपयोगकर्ताओं के लिए स्पष्टता बढ़ती है और वे आपके WASM मॉड्यूल से उत्पन्न विभिन्न त्रुटि स्थितियों में अंतर कर सकते हैं।

त्रुटियों के लिए विशिष्ट Rust एनम परिभाषित करें।
उन्हें बदलने के लिए From<YourError> for JsValue लागू करें।
कस्टम JS त्रुटि नामों के लिए #[wasm_bindgen(js_name = MyCustomError)] का उपयोग करें।

त्रुटि प्रबंधन की सर्वोत्तम पद्धतियाँ

रखरखाव योग्य और मजबूत WASM एप्लिकेशनों के लिए प्रभावी त्रुटि प्रबंधन महत्वपूर्ण है:

स्पष्ट रहें: अपने WASM कोड में त्रुटि स्थितियों और रिटर्न प्रकारों को स्पष्ट रूप से परिभाषित करें।
त्रुटियाँ लॉग करें: WASM त्रुटियों को दर्ज करने के लिए JavaScript में console.error या किसी लॉगिंग उपयोगिता का उपयोग करें।
सहज रूप से सीमित कार्यक्षमता: अपने एप्लिकेशन को इस तरह डिज़ाइन करें कि WASM का कोई घटक गैर-महत्वपूर्ण त्रुटि का सामना करने पर भी वह काम करता रहे।
त्रुटि मार्गों का परीक्षण करें: सुनिश्चित करें कि सभी विफलता परिदृश्यों को शामिल करने के लिए आपके त्रुटि प्रबंधन तर्क का पूरी तरह परीक्षण किया गया हो।

त्रुटि प्रसार जाँच

निम्नलिखित Rust WebAssembly फ़ंक्शन और उससे इंटरैक्ट करने वाले JavaScript कोड पर विचार कीजिए। जब runExample() को कॉल किया जाएगा, तो JavaScript कंसोल में क्या आउटपुट दिखाई देगा?

Rust WASM मॉड्यूल (lib.rs):

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn check_value(value: i32) -> Result<String, JsValue> {
    if value < 0 {
        Err(JsValue::from_str("Value cannot be negative!"))
    } else if value == 0 {
        Ok("Value is zero.".into())
    } else {
        Ok(format!("Value is positive: {}", value))
    }
}

JavaScript होस्ट कोड:

// Assume 'wasm' is the loaded WASM module via wasm-bindgen
async function runExample() {
  // For context, 'wasm' would be loaded like this:
  // const wasm = await import('./my_wasm_module.js'); 

  // For this question, assume 'wasm.check_value' behaves as defined in Rust.
  const wasm = {
    check_value: (val) => {
      if (val < 0) throw new Error("Value cannot be negative!");
      if (val === 0) return "Value is zero.";
      return `Value is positive: ${val}`;
    }
  };

  try {
    console.log(wasm.check_value(5));
    console.log(wasm.check_value(-1)); // This will throw
  } catch (e) {
    console.error("Caught error:", e.message);
  }
  console.log(wasm.check_value(0)); // This line is outside the try...catch
}
runExample();

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: मज़बूत त्रुटि प्रबंधन

इस पाठ में हमने WebAssembly और JavaScript के बीच इंटरऑपरेशन करते समय त्रुटियों और अपवादों को संभालने का तरीका समझा। हमने सीखा:

WASM की होस्ट भाषाएँ त्रुटियों के लिए विशिष्ट पैटर्न, जैसे Rust का Result प्रकार, इस्तेमाल करती हैं।
wasm-bindgen WASM की त्रुटियों को JavaScript के Error ऑब्जेक्ट में पहुँचाने की प्रक्रिया को स्वचालित करता है।
JavaScript का try...catch WASM मॉड्यूल द्वारा उत्पन्न त्रुटियों को प्रभावी ढंग से संभाल सकता है।
WASM अपने द्वारा बुलाए गए JavaScript कॉलबैक से आने वाली त्रुटियों को भी संभाल सकता है।

विश्वसनीय और उपयोगकर्ता-अनुकूल WASM अनुप्रयोग बनाने के लिए त्रुटि प्रबंधन में दक्षता हासिल करना बेहद महत्वपूर्ण है।

शुरुआत निःशुल्क

एआई शिक्षक के साथ उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “त्रुटि प्रबंधन और अपवाद” पाठ निःशुल्क है?

हाँ—“त्रुटि प्रबंधन और अपवाद” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“त्रुटि प्रबंधन और अपवाद” में मैं क्या सीखूँगा?

WASM और JavaScript कोड के बीच त्रुटियों और अपवादों को प्रभावी ढंग से आगे भेजने और सँभालने की मजबूत रणनीतियाँ सीखें आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“त्रुटि प्रबंधन और अपवाद” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

WASM के साथ अतुल्यकालिक ऑपरेशन
कस्टम JavaScript कॉलबैक
त्रुटि प्रबंधन और अपवाद
JS/WASM सीमा के पार मेमोरी और टाइप्ड ऐरे साझा करना

← उच्च-प्रदर्शन अनुप्रयोगों के लिए WebAssembly (WASM) पर वापस जाएँ