जावास्क्रिप्ट में स्टेटमेंट्स को सरल कैसे करें

सशर्त बयान जावास्क्रिप्ट का एक अनिवार्य हिस्सा हैं। वे आपको दी गई स्थिति के सही या गलत होने के आधार पर कोड निष्पादित करने देते हैं, और आप कई को नेस्ट कर सकते हैं elif बयान (और एक अन्य) एक से अधिक शर्तों का मूल्यांकन करने के लिए।

लेकिन यहाँ समस्या है - जटिल लिखते समय यदि नहीं तो जंजीरों, चीजें जल्दी गड़बड़ हो सकती हैं, और आप आसानी से कोड के साथ समाप्त हो सकते हैं जिसे पढ़ना और समझना मुश्किल है।

आइए जानें कि लंबे और जटिल रिफैक्टर कैसे करें अगर... और... और सशर्त जंजीरों को अधिक संक्षिप्त, स्वच्छ और आसानी से समझने वाले संस्करण में।

जटिल अगर... और चेन

जावास्क्रिप्ट में जटिल if...else स्टेटमेंट लिखते समय, यह आवश्यक है कि आप लिखें स्वच्छ, संक्षिप्त और समझने योग्य कोड. उदाहरण के लिए, पर एक नज़र डालें यदि नहीं तो नीचे दिए गए फ़ंक्शन के अंदर सशर्त श्रृंखला:

समारोहcandrink(व्यक्ति) {
अगर(व्यक्ति? उम्र! = व्यर्थ) {
अगर(व्यक्ति।आयु < 18) {
सांत्वना देना।लकड़ी का लट्ठा("अभी भी बहुत छोटा है")
 } अन्यअगर(व्यक्ति उम्र < 21) {
सांत्वना देना।लकड़ी का लट्ठा(

instagram viewer

"अमेरिका में नहीं")
 } अन्य {
सांत्वना देना।लकड़ी का लट्ठा("पीने ​​की अनुमति")
 }
 } अन्य {
सांत्वना देना।लकड़ी का लट्ठा("तुम एक व्यक्ति नहीं हो")
 }
}
कॉन्स्ट व्यक्ति = {
 आयु: 22
}
कैनड्रिंक (व्यक्ति)

यहाँ तर्क सरल है। पहला अगर बयान सुनिश्चित करता है कि व्यक्ति वस्तु में एक है आयु संपत्ति (अन्यथा वह एक व्यक्ति नहीं है)। उसके अंदर अगर ब्लॉक, आपने एक जोड़ा है अगर... और... अगर श्रृंखला जो मूल रूप से कहती है:

यदि व्यक्ति की आयु 18 वर्ष से कम है, तो वह शराब पीने के लिए बहुत छोटा है। यदि 21 वर्ष से कम उम्र के हैं, तो वे अभी भी संयुक्त राज्य अमेरिका में शराब पीने की कानूनी उम्र से कम हैं। अन्यथा, वे कानूनी रूप से शराब पी सकते हैं।

जबकि उपरोक्त कोड मान्य है, नेस्टिंग आपके लिए कोड को समझना कठिन बना देता है। सौभाग्य से, आप a का उपयोग करके कोड को संक्षिप्त और पढ़ने में आसान बनाने के लिए रिफ्लेक्टर कर सकते हैं गार्ड क्लॉज.

गार्ड क्लाज

जब भी आपके पास एक अगर बयान जो आपके सभी कोड को लपेटता है, आप इसका उपयोग कर सकते हैं गार्ड क्लॉज सभी नेस्टिंग को हटाने के लिए:

समारोहcanDrinkBetter() {
अगर(व्यक्ति? उम्र == व्यर्थ) वापस करनासांत्वना देना।लकड़ी का लट्ठा("तुम एक व्यक्ति नहीं हो") 
अगर(व्यक्ति।आयु < 18) {
सांत्वना देना।लकड़ी का लट्ठा("अभी भी बहुत छोटा है")
 } अन्यअगर(व्यक्ति उम्र < 21) {
सांत्वना देना।लकड़ी का लट्ठा("अमेरिका में नहीं")
 } अन्य {
सांत्वना देना।लकड़ी का लट्ठा("पीने ​​की अनुमति")
 }
}

फ़ंक्शन की शुरुआत में, आपने एक गार्ड क्लॉज परिभाषित किया था जिसमें कहा गया था कि यदि वह विशिष्ट स्थिति पूरी नहीं हुई है, तो आप बाहर निकलना चाहते हैं कैनड्रिंक बेटर () तुरंत कार्य करें (और कंसोल पर "आप एक व्यक्ति नहीं हैं" लॉग करें)।

लेकिन अगर शर्त पूरी होती है, तो आप मूल्यांकन करते हैं यदि नहीं तो श्रृंखला यह देखने के लिए कि कौन सा ब्लॉक लागू है। कोड चलाना आपको पहले उदाहरण के समान परिणाम देता है, लेकिन यह कोड पढ़ने में आसान है।

सिंगल रिटर्न का उपयोग न करें

आप तर्क दे सकते हैं कि उपरोक्त तकनीक a नहीं है अच्छा प्रोग्रामिंग सिद्धांत क्योंकि हम एक ही फ़ंक्शन में एकाधिक रिटर्न का उपयोग कर रहे हैं, और आप मानते हैं कि केवल एक रिटर्न स्टेटमेंट (उर्फ, सिंगल रिटर्न पॉलिसी) होना बेहतर है।

लेकिन यह कोड लिखने का एक भयानक तरीका है क्योंकि यह आपको उसी पागल घोंसले की स्थिति में मजबूर करता है जिसे हमने पहले कोड नमूने में देखा था।

इसके साथ ही, आप एकाधिक का उपयोग कर सकते हैं वापस करना अपने कोड को और सरल बनाने के लिए कथन (और नेस्टिंग से छुटकारा पाएं):

समारोहcanDrinkBetter() {
अगर(व्यक्ति? उम्र == व्यर्थ) वापस करनासांत्वना देना।लकड़ी का लट्ठा("तुम एक व्यक्ति नहीं हो") 
अगर(व्यक्ति।आयु < 18) {
सांत्वना देना।लकड़ी का लट्ठा("अभी भी बहुत छोटा है")
वापस करना
 } 
अगर(व्यक्ति।आयु < 21) {
सांत्वना देना।लकड़ी का लट्ठा("अमेरिका में नहीं")
वापस करना
 }
सांत्वना देना।लकड़ी का लट्ठा("पीने ​​की अनुमति") 
}

यह कोड पिछले दो उदाहरणों की तरह ही काम करता है, और यह थोड़ा साफ भी है।

क्लीनर कोड के लिए कार्य निकालें

हमारा पिछला कोड ब्लॉक पहले दो की तुलना में साफ था, लेकिन यह अभी भी उतना अच्छा नहीं है जितना हो सकता है।

लंबा होने के बजाय यदि नहीं तो एक फ़ंक्शन के अंदर चेन, आप एक अलग फ़ंक्शन बना सकते हैं canDrinkResult () यह आपके लिए जांच करता है और परिणाम देता है:

समारोहcanDrinkResult(आयु) {
अगर(उम्र < 18) वापस करना"अभी भी बहुत छोटा है"
अगर(उम्र < 21) वापस करना"अमेरिका में नहीं"
वापस करना"पीने ​​की अनुमति"
}

फिर मुख्य फ़ंक्शन के अंदर, आपको केवल कॉल करने से पहले गार्ड क्लॉज लागू करना होगा canDrinkResult () परिणाम प्राप्त करने के लिए कार्य (इसके पैरामीटर के रूप में आयु के साथ):

समारोहcanDrinkBetter() { 
अगर(व्यक्ति? उम्र == व्यर्थ) वापस करनासांत्वना देना।लकड़ी का लट्ठा("तुम एक व्यक्ति नहीं हो") 
होने देना परिणाम = canDrinkResult (व्यक्ति.उम्र)
सांत्वना देनालॉग (परिणाम)
}

तो इस मामले में, आपने पीने की उम्र की जाँच करने का काम एक अलग समारोह में सौंप दिया और जरूरत पड़ने पर ही इसे बुलाया। यह आपके कोड को पिछले सभी उदाहरणों की तुलना में काम करने के लिए संक्षिप्त और अधिक सरल बनाता है।

अन्यथा सशर्त वक्तव्यों से दूर रहें

आपने गार्ड क्लॉज और फ़ंक्शन निष्कर्षण तकनीक का उपयोग करके जटिल, नेस्टेड सशर्त श्रृंखलाओं को छोटे, आसानी से पढ़ने वाले लोगों में रिफलेक्टर करना सीखा है।

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

यदि आप अभी भी जावास्क्रिप्ट का उपयोग करने के लिए नए हैं यदि नहीं तो कथन, मूल बातों से शुरू करें।