त्रुटि प्रबंधन मजबूत और विश्वसनीय सॉफ्टवेयर लिखने का एक महत्वपूर्ण पहलू है। हालाँकि, सावधानी से नहीं किए जाने से कोड अव्यवस्थित हो सकता है जिसे पढ़ना और बनाए रखना कठिन है।

क्लीन कोड का अध्याय 7 उन त्रुटियों से निपटने की तकनीकों पर प्रकाश डालता है जो स्पष्टता और सरलता पर जोर देते हुए आपके कोड को अव्यवस्थित नहीं करती हैं।

इस लेख में, हम इस अध्याय से मुख्य अवधारणाओं का पता लगाएंगे और अपने कोडबेस को साफ और बनाए रखने योग्य बनाए रखने के लिए उन्हें जावास्क्रिप्ट में कैसे लागू करें।

? 1. त्रुटि कोड के बजाय अपवादों का उपयोग करें

क्लीन कोड में प्रमुख सिद्धांतों में से एक त्रुटि कोड पर अपवादों को प्राथमिकता देना है।

अपवाद आपको त्रुटि-हैंडलिंग तर्क को अपने मुख्य तर्क से अलग करने की अनुमति देते हैं, जिससे आपका कोड अधिक पठनीय हो जाता है।

उदाहरण: त्रुटि कोड से बचें

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        return -1;  // Error code for user not found
    }
    return user;
}

const result = getUser(123);
if (result === -1) {
    console.error('User not found');
} else {
    console.log(result);
}

इस उदाहरण में, त्रुटि प्रबंधन मुख्य तर्क के साथ जुड़ा हुआ है, जिससे इसका पालन करना कठिन हो जाता है।

उदाहरण: अपवादों का उपयोग करें

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error('User not found');
    }
    return user;
}

try {
    const user = getUser(123);
    console.log(user);
} catch (error) {
    console.error(error.message);
}

अपवादों का उपयोग करके, हम त्रुटि-हैंडलिंग तर्क को मुख्य तर्क से अलग करते हैं, जिससे कोड साफ-सुथरा और समझने में आसान हो जाता है।

? 2. सार्थक संदेशों के साथ संदर्भ प्रदान करें

अपवाद फेंकते समय, सार्थक त्रुटि संदेश प्रदान करना महत्वपूर्ण है जो त्रुटि के बारे में संदर्भ देते हैं।

यह कोड को गहराई से जाने बिना समस्याओं का त्वरित निदान करने में मदद करता है।

उदाहरण: त्रुटि संदेशों में संदर्भ प्रदान करें

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error(`User with ID ${id} not found`);
    }
    return user;
}

try {
    const user = getUser(123);
    console.log(user);
} catch (error) {
    console.error(error.message);  // Outputs: User with ID 123 not found
}

एक वर्णनात्मक त्रुटि संदेश समस्या को तुरंत समझने के लिए आवश्यक संदर्भ प्रदान करता है।

? 3. शून्य न लौटें

शून्य लौटने से शून्य संदर्भ त्रुटियां हो सकती हैं जिनका पता लगाना मुश्किल होता है।

शून्य लौटने के बजाय, एक अपवाद फेंकने या एक विशेष केस पैटर्न का उपयोग करने पर विचार करें जो डिफ़ॉल्ट व्यवहार प्रदान करता है।

उदाहरण: शून्य लौटने से बचें

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        return null;  // This can lead to null reference errors
    }
    return user;
}

const user = getUser(123);
if (user !== null) {
    console.log(user.name);
}

शून्य लौटने के लिए अतिरिक्त जांच की आवश्यकता होती है और यह आपके कोड को अव्यवस्थित कर सकता है।

उदाहरण: एक अपवाद फेंकें या एक विशेष मामले का उपयोग करें

function getUser(id) {
    const user = database.findUserById(id);
    if (user === null) {
        throw new Error(`User with ID ${id} not found`);
    }
    return user;
}

// OR

class NullUser {
    get name() {
        return 'Guest';
    }
}

function getUser(id) {
    const user = database.findUserById(id);
    return user || new NullUser();
}

अपवाद फेंकने या किसी विशेष केस ऑब्जेक्ट (जैसे NullUser) का उपयोग करने से शून्य संदर्भ त्रुटियों से बचने में मदद मिलती है और आपका कोड साफ़ रहता है।

? 4. ट्राई-कैच-फाइनली का संयम से प्रयोग करें

जबकि अपवादों को संभालने के लिए ट्राई-कैच-फाइनली ब्लॉक आवश्यक हैं, उनका अत्यधिक उपयोग आपके कोड को अव्यवस्थित कर सकता है।

आवश्यक होने पर ही उनका उपयोग करें और गहरे नेस्टेड ब्लॉकों से बचें।

उदाहरण: अत्यधिक प्रयास-पकड़ने से बचें

try {
    const data = JSON.parse(input);
    try {
        const user = getUser(data.id);
        try {
            sendEmail(user.email);
        } catch (error) {
            console.error('Failed to send email:', error.message);
        }
    } catch (error) {
        console.error('User retrieval failed:', error.message);
    }
} catch (error) {
    console.error('Invalid JSON:', error.message);
}

कई नेस्टेड ट्राई-कैच ब्लॉक के कारण इस कोड का पालन करना कठिन है।

उदाहरण: अव्यवस्था को कम करने के लिए रिफैक्टर

function parseInput(input) {
    try {
        return JSON.parse(input);
    } catch (error) {
        throw new Error('Invalid JSON');
    }
}

function retrieveUser(data) {
    return getUser(data.id);
}

function notifyUser(user) {
    sendEmail(user.email);
}

try {
    const data = parseInput(input);
    const user = retrieveUser(data);
    notifyUser(user);
} catch (error) {
    console.error(error.message);
}

तर्क को अलग-अलग कार्यों में तोड़कर, हम नेस्टिंग को कम करते हैं और पठनीयता में सुधार करते हैं।

? 5. पकड़े गए अपवादों को नजरअंदाज न करें

यदि आपको कोई अपवाद मिलता है, तो उसे ठीक से संभालना सुनिश्चित करें।

अपवादों को चुपचाप अनदेखा करने से अप्रत्याशित व्यवहार हो सकता है और डिबगिंग मुश्किल हो सकती है।

उदाहरण: अपवादों को नजरअंदाज न करें

try {
    const user = getUser(123);
} catch (error) {
    // Ignoring the exception
}

अपवादों को अनदेखा करने से आपके कोड में संभावित समस्याएं छिप सकती हैं।

उदाहरण: अपवाद को संभालें या लॉग करें

try {
    const user = getUser(123);
} catch (error) {
    console.error('An error occurred:', error.message);
}

अपवाद को संभालने या लॉग करने से यह सुनिश्चित होता है कि आप किसी भी मुद्दे से अवगत हैं और तदनुसार उन्हें संबोधित कर सकते हैं।

⚡निष्कर्ष

स्वच्छ, रखरखाव योग्य जावास्क्रिप्ट कोड लिखने के लिए प्रभावी त्रुटि प्रबंधन आवश्यक है।

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

हैप्पी कोडिंग!