TypeScript में त्रुटि प्रबंधन: try/catch और उन्नत विधियाँ

TypeScript में त्रुटि प्रबंधन: try/catch से विश्वसनीय कोड तक

TypeScript JavaScript में स्थैतिक टाइपिंग जोड़ता है, लेकिन रनटाइम त्रुटियाँ विकास का एक अनिवार्य हिस्सा बनी रहती हैं। गलत अपवाद प्रबंधन से एप्लिकेशन क्रैश हो सकता है, डेटा लीक हो सकता है, या उपयोगकर्ता इंटरफ़ेस गलत तरीके से काम कर सकता है। इस लेख में, हम TypeScript में त्रुटियों को प्रभावी ढंग से संभालने के तरीके पर चर्चा करेंगे, जिसमें अंतर्निहित तंत्र और उन्नत पैटर्न का उपयोग किया जाएगा।

TypeScript में बुनियादी try/catch

try/catch कंस्ट्रक्शन त्रुटि प्रबंधन का आधार है। TypeScript में, JavaScript के विपरीत, हम पकड़ी गई त्रुटि को टाइप कर सकते हैं। हालाँकि, एक महत्वपूर्ण बारीकियाँ है: डिफ़ॉल्ट रूप से, catch ब्लॉक में त्रुटि का प्रकार unknown होता है, न कि Error।

try {    const data = JSON.parse('अमान्य json');    console.log(data);} catch (error) {    // error का प्रकार unknown है    if (error instanceof Error) {        console.error('एक त्रुटि हुई:', error.message);    } else {        console.error('अज्ञात त्रुटि:', error);    }}

यह क्यों महत्वपूर्ण है? JavaScript में, आप कुछ भी फेंक सकते हैं: एक स्ट्रिंग, एक संख्या, एक ऑब्जेक्ट। TypeScript हमें बिना जाँच के त्रुटि के गुणों तक असुरक्षित पहुँच से बचाता है। उपयोग करने से पहले हमेशा त्रुटि के प्रकार की जाँच करने की अनुशंसा की जाती है।

कस्टम त्रुटि वर्ग

अधिक सटीक प्रबंधन के लिए, अपने स्वयं के त्रुटि वर्ग बनाएँ जो अंतर्निहित Error का विस्तार करते हैं। यह त्रुटियों के प्रकारों में अंतर करने और अतिरिक्त जानकारी प्रसारित करने की अनुमति देता है।

class ValidationError extends Error {    constructor(        public field: string,        message: string    ) {        super(message);        this.name = 'ValidationError';    }}

class NetworkError extends Error {    constructor(        public statusCode: number,        message: string    ) {        super(message);        this.name = 'NetworkError';    }}

function processUserData(data: unknown): void {    if (!data || typeof data !== 'object') {        throw new ValidationError('data', 'अमान्य डेटा');    }        if (!('email' in data)) {        throw new ValidationError('email', 'ईमेल अनिवार्य है');    }}

try {    processUserData({ name: 'इवान' });} catch (error) {    if (error instanceof ValidationError) {        console.error(`फ़ील्ड ${error.field} का सत्यापन त्रुटि: ${error.message}`);    } else if (error instanceof NetworkError) {        console.error(`नेटवर्क त्रुटि ${error.statusCode}: ${error.message}`);    } else {        console.error('अज्ञात त्रुटि:', error);    }}

यह दृष्टिकोण कोड को स्व-दस्तावेज़ीकृत बनाता है और डिबगिंग को सरल बनाता है। आप हमेशा जानते हैं कि त्रुटि कहाँ और क्यों हुई।

त्रुटियों वाले फ़ंक्शन का टाइपिंग: never और discriminated unions

TypeScript टाइप स्तर पर त्रुटियों के साथ काम करने के लिए शक्तिशाली उपकरण प्रदान करता है। उन फ़ंक्शन के लिए never प्रकार का उपयोग करें जो हमेशा एक अपवाद फेंकते हैं, और त्रुटियों को वापस करने के लिए discriminated unions का उपयोग करें।

function throwError(message: string): never {    throw new Error(message);}

// परिणाम के लिए Discriminated uniontype Result<T> =     | { success: true; data: T }    | { success: false; error: string };

function fetchUser(id: number): Result<{ name: string }> {    try {        // अनुरोध का अनुकरण        if (id <= 0) {            return { success: false, error: 'अमान्य ID' };        }        return { success: true, data: { name: 'अन्ना' } };    } catch (error) {        return { success: false, error: 'नेटवर्क त्रुटि' };    }}

const result = fetchUser(1);if (result.success) {    console.log('उपयोगकर्ता:', result.data.name);} else {    console.error('त्रुटि:', result.error);}

Result पैटर्न अंतर्निहित अपवादों से बचने की अनुमति देता है और त्रुटि प्रबंधन को अधिक स्पष्ट बनाता है।