जावास्क्रिप्ट में लौटें कि यह कैसे काम करता है। अभिव्यंजक जावास्क्रिप्ट: कार्य। स्थानीय और वैश्विक चर

जंप स्टेटमेंट और अपवाद हैंडलिंग

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

रिटर्न स्टेटमेंट दुभाषिया को कॉल किए गए फ़ंक्शन से उस बिंदु पर वापस जाने का कारण बनता है जहां उसे कॉल किया गया था और कॉल का मान लौटाता है। थ्रो स्टेटमेंट एक अपवाद उठाता है और इसका उद्देश्य ब्लॉक को परिभाषित करने वाले ट्राइ/कैच/फाइनली स्टेटमेंट के साथ मिलकर काम करना है प्रोग्राम कोडअपवाद को संभालने के लिए. यह एक जटिल प्रकार का जंप ऑपरेटर है: जब कोई अपवाद होता है, तो दुभाषिया निकटतम संलग्न अपवाद हैंडलर पर चला जाता है, जो कॉल किए गए फ़ंक्शन के रिटर्न स्टैक में समान फ़ंक्शन या उच्चतर में हो सकता है।

इन सभी जंप ऑपरेटरों का निम्नलिखित उपधाराओं में अधिक विस्तार से वर्णन किया गया है।

किसी भी निर्देश को एक पहचानकर्ता और एक कोलन से चिह्नित किया जा सकता है:

आईडी: निर्देश

किसी निर्देश को चिह्नित करके, आप उसे एक नाम देते हैं, जिसे बाद में प्रोग्राम में कहीं भी संदर्भ के रूप में उपयोग किया जा सकता है। आप किसी भी निर्देश को चिह्नित कर सकते हैं, लेकिन यह केवल उन निर्देशों को चिह्नित करने के लिए समझ में आता है जिनमें कोई बॉडी होती है, जैसे लूप और सशर्त कथन।

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

मेनलूप: जबकि (टोकन! = शून्य) ( // प्रोग्राम कोड छोड़ा गया... मेनलूप जारी रखें; // नामित लूप के अगले पुनरावृत्ति पर जाएं)

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

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

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

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

वर एआर = ["ए","बी","सी","डी","डी"], परिणाम; के लिए (var i = 0; i

जावास्क्रिप्ट में, आप ब्रेक कीवर्ड (बिना कोलन के पहचानकर्ता) के बाद लेबल का नाम निर्दिष्ट कर सकते हैं:

ब्रेक लेबल_नाम;

जब ब्रेक स्टेटमेंट का उपयोग किसी लेबल के साथ किया जाता है, तो यह नामित स्टेटमेंट के अंत तक पहुंच जाता है या इसके निष्पादन को समाप्त कर देता है। यदि निर्दिष्ट लेबल के साथ कोई स्टेटमेंट नहीं है, तो ब्रेक स्टेटमेंट के इस फॉर्म का उपयोग करने का प्रयास एक सिंटैक्स त्रुटि उत्पन्न करता है। नामित स्टेटमेंट का लूप या स्विच स्टेटमेंट होना जरूरी नहीं है। एक लेबल वाला ब्रेक स्टेटमेंट किसी भी युक्त स्टेटमेंट से अलग हो सकता है। एक रैपर निर्देश इसे लेबल करने के एकमात्र उद्देश्य के लिए घुंघराले ब्रेसिज़ में संलग्न निर्देशों का एक सरल ब्लॉक भी हो सकता है।

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

एक लेबल ब्रेक स्टेटमेंट की आवश्यकता केवल तभी होती है जब आप किसी ऐसे स्टेटमेंट के निष्पादन को बाधित करना चाहते हैं जो निकटतम एन्क्लोजिंग लूप या स्विच स्टेटमेंट नहीं है।

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

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

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

करो/जबकि लूप लूप के अंत तक पहुंच जाता है, जहां लूप को दोबारा निष्पादित करने से पहले स्थिति की दोबारा जांच की जाती है।

फॉर लूप वृद्धि अभिव्यक्ति का मूल्यांकन करता है और यह निर्धारित करने के लिए परीक्षण अभिव्यक्ति का फिर से मूल्यांकन करता है कि अगला पुनरावृत्ति निष्पादित किया जाना चाहिए या नहीं।

फॉर/इन लूप में, अगली प्रॉपर्टी के नाम पर निर्दिष्ट वेरिएबल निर्दिष्ट करके लूप फिर से शुरू होता है।

while और for लूप में जारी कथन के व्यवहार में अंतर पर ध्यान दें। जबकि लूप सीधे अपनी स्थिति पर लौटता है, और पाश के लिएपहले वृद्धि अभिव्यक्ति का मूल्यांकन करता है और फिर स्थिति पर लौटता है। निम्नलिखित उदाहरण सम संख्याओं के लिए वर्तमान लूप पुनरावृत्ति से बाहर निकलने के लिए बिना किसी लेबल के जारी रखें कथन का उपयोग दिखाता है:

वर योग = 0; // (var i = 0; i के लिए 0 - 10 तक विषम संख्याओं के योग की गणना करें

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

फ़ंक्शन कॉल एक अभिव्यक्ति है और, सभी अभिव्यक्तियों की तरह, इसका एक मान होता है। फ़ंक्शन के अंदर रिटर्न स्टेटमेंट का उपयोग फ़ंक्शन द्वारा लौटाए गए मान को निर्धारित करने के लिए किया जाता है। रिटर्न स्टेटमेंट केवल किसी फ़ंक्शन के मुख्य भाग में दिखाई दे सकता है। किसी अन्य स्थान पर इसकी उपस्थिति एक वाक्यविन्यास त्रुटि है। जब रिटर्न स्टेटमेंट निष्पादित किया जाता है, तो फ़ंक्शन कॉलिंग प्रोग्राम को अभिव्यक्ति का मान लौटाता है। उदाहरण के लिए:

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

रिटर्न स्टेटमेंट का उपयोग किसी अभिव्यक्ति के बिना भी किया जा सकता है, ऐसी स्थिति में यह केवल फ़ंक्शन को निरस्त कर देता है और कॉलिंग प्रोग्राम में अपरिभाषित वापस आ जाता है। उदाहरण के लिए:

फ़ंक्शन myFun(arr) ( // यदि सरणी में नकारात्मक संख्याएं हैं, तो (var i = 0; i) के लिए फ़ंक्शन को निरस्त करें

अपवाद एक संकेत है जो दर्शाता है कि किसी प्रकार की असाधारण स्थिति या त्रुटि उत्पन्न हुई है। एक अपवाद फेंकनाऐसी त्रुटि या अपवाद का संकेत देने का एक तरीका है। किसी अपवाद को पकड़ने का अर्थ है उसे संसाधित करना, अर्थात अपवाद से उबरने के लिए आवश्यक या उचित कार्रवाई करें।

में जावास्क्रिप्ट अपवादरन-टाइम त्रुटि होने पर उठाया जाता है और जब प्रोग्राम थ्रो स्टेटमेंट का उपयोग करके इसे स्पष्ट रूप से उठाता है। अपवादों को प्रयास/पकड़/अंततः कथनों का उपयोग करके पकड़ा जाता है, जिनका वर्णन बाद में किया गया है।

थ्रो स्टेटमेंट में निम्नलिखित सिंटैक्स है:

अभिव्यक्ति फेंको;

अभिव्यक्ति का परिणाम किसी भी प्रकार का मान हो सकता है। थ्रो स्टेटमेंट को एक त्रुटि कोड या त्रुटि संदेश के पाठ वाली स्ट्रिंग का प्रतिनिधित्व करने वाला एक नंबर पारित किया जा सकता है। जावास्क्रिप्ट दुभाषिया अपने उपवर्गों में से एक के त्रुटि वर्ग के उदाहरण का उपयोग करके अपवाद फेंकता है, और आप एक समान दृष्टिकोण का उपयोग कर सकते हैं। त्रुटि ऑब्जेक्ट में एक संपत्ति है नाम, जो त्रुटि के प्रकार और गुण को परिभाषित करता है संदेशजिसमें कंस्ट्रक्टर फ़ंक्शन को पास की गई स्ट्रिंग शामिल है। निम्नलिखित एक फ़ंक्शन का उदाहरण है जो अमान्य तर्क के साथ बुलाए जाने पर एक त्रुटि ऑब्जेक्ट उठाता है:

// नंबर फैक्टोरियल फ़ंक्शन फ़ंक्शन फैक्टोरियल (संख्या) ( // यदि इनपुट तर्क वैध मान नहीं है, // एक अपवाद फेंक दिया गया है! यदि (नंबर 1; i * = संख्या, संख्या -); / * खाली लूप बॉडी */ रिटर्न आई ; ) कंसोल.लॉग("5! = ", फैक्टोरियल(5)); कंसोल.लॉग("-3! = ", फैक्टोरियल(-3));

जब कोई अपवाद उठाया जाता है, तो जावास्क्रिप्ट दुभाषिया तुरंत सामान्य प्रोग्राम निष्पादन को बाधित कर देता है और निकटतम अपवाद हैंडलर पर चला जाता है। अपवाद हैंडलर ट्राई/कैच/अंततः कैच क्लॉज का उपयोग करते हैं, जिसका वर्णन अगले भाग में किया गया है।

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

यदि किसी फ़ंक्शन में कोई अपवाद फेंक दिया जाता है जिसमें इसे संभालने के लिए प्रयास/पकड़/अंततः निर्माण नहीं होता है, तो अपवाद को उस कोड तक प्रचारित किया जाता है जिसे फ़ंक्शन कहा जाता है। इस प्रकार अपवादों को शाब्दिक संरचना के माध्यम से प्रचारित किया जाता है जावास्क्रिप्ट विधियाँकॉल स्टैक ऊपर. यदि कोई अपवाद हैंडलर कभी नहीं मिलता है, तो अपवाद को एक त्रुटि के रूप में माना जाता है और उपयोगकर्ता को रिपोर्ट किया जाता है।

प्रयास/पकड़/अंततः निर्माण जावास्क्रिप्ट में अपवाद हैंडलिंग तंत्र को कार्यान्वित करता है। इस निर्माण में प्रयास कथन केवल कोड के एक ब्लॉक को परिभाषित करता है जिसमें अपवादों को संभाला जाता है। ट्राई ब्लॉक के बाद कैच स्टेटमेंट के साथ स्टेटमेंट्स का एक ब्लॉक होता है, जिसे ट्राई ब्लॉक में कहीं भी अपवाद होने पर कॉल किया जाता है। कैच स्टेटमेंट के बाद अंत में ब्लॉक होता है, जिसमें अंतिम कोड होता है जो कि ट्राई ब्लॉक में कुछ भी होने की परवाह किए बिना चलने की गारंटी देता है।

कैच ब्लॉक और अंततः ब्लॉक दोनों वैकल्पिक हैं, लेकिन उनमें से कम से कम एक को ट्राई ब्लॉक के बाद मौजूद होना चाहिए। कोशिश करें, पकड़ें और अंत में प्रारंभ और अंत को अवरुद्ध करें घुंघराले ब्रेसिज़. यह वाक्यविन्यास का एक आवश्यक हिस्सा है और इसे छोड़ा नहीं जा सकता, भले ही बीच में केवल एक निर्देश हो।

निम्नलिखित स्निपेट प्रयास/पकड़/अंततः निर्माण के सिंटैक्स और उद्देश्य को दर्शाता है:

प्रयास करें ( // यह कोड आमतौर पर शुरू से अंत तक सुचारू रूप से चलता है। // लेकिन कुछ बिंदु पर यह एक अपवाद फेंक सकता है // या तो सीधे थ्रो स्टेटमेंट का उपयोग करके, या अप्रत्यक्ष रूप से // एक विधि को कॉल करके जो अपवाद फेंकता है।) पकड़ें ( पूर्व) (//इस ब्लॉक में कथन तभी निष्पादित होते हैं जब प्रयास ब्लॉक में कोई अपवाद // होता है। ये कथन स्थानीय चर पूर्व का उपयोग कर सकते हैं, जो // एक त्रुटि ऑब्जेक्ट या थ्रो में निर्दिष्ट किसी अन्य मान को संदर्भित करता है स्टेटमेंट। // यह ब्लॉक या तो किसी तरह से अपवाद को संभाल सकता है, // कुछ और करते समय इसे अनदेखा कर सकता है, या थ्रो स्टेटमेंट का उपयोग करके अपवाद को फिर से फेंक सकता है) अंत में ( // इस ब्लॉक में ऐसे स्टेटमेंट होते हैं जिन्हें हमेशा बिना किसी परवाह के निष्पादित किया जाता है। , // प्रयास ब्लॉक में क्या हुआ। यदि प्रयास ब्लॉक पूरा हो गया है तो उन्हें निष्पादित किया जाता है: // 1) हमेशा की तरह, ब्लॉक के अंत तक पहुंचना // 2) ब्रेक के कारण, जारी रखें या रिटर्न स्टेटमेंट // 3 ) ऊपर कैच ब्लॉक में संभाले गए अपवाद के साथ // 4) एक न देखे गए अपवाद के साथ जो // उच्च स्तर तक प्रसारित होता रहता है)

ध्यान दें कि कैच कीवर्ड के बाद कोष्ठक में एक पहचानकर्ता आता है। यह पहचानकर्ता फ़ंक्शन पैरामीटर के समान है। जब कोई अपवाद पकड़ा जाता है, तो यह पैरामीटर अपवाद को सौंपा जाएगा (उदाहरण के लिए, एक त्रुटि ऑब्जेक्ट)। एक नियमित चर के विपरीत, कैच स्टेटमेंट से जुड़ा पहचानकर्ता केवल कैच ब्लॉक के मुख्य भाग में मौजूद होता है।

निम्नलिखित प्रयास/पकड़ निर्माण का अधिक यथार्थवादी उदाहरण है। यह इनपुट और आउटपुट को व्यवस्थित करने के लिए पिछले उदाहरण में परिभाषित फ़ैक्टोरियल() विधि और क्लाइंट जावास्क्रिप्ट प्रॉम्प्ट() और अलर्ट() विधियों को कॉल करता है:

प्रयास करें ( // उपयोगकर्ता से एक नंबर का अनुरोध करें var n = Number(prompt('Enter सकारात्मक संख्या", "")); // किसी संख्या के फैक्टोरियल की गणना करें, यह मानते हुए कि // इनपुट डेटा सही है var f = Factorial(n); // परिणाम अलर्ट प्रिंट करें (n + "! = " + f); ) पकड़ो (पूर्व) ( // यदि डेटा गलत है, तो नियंत्रण यहां स्थानांतरित किया जाएगा चेतावनी (पूर्व); // उपयोगकर्ता को त्रुटि के बारे में सूचित करें)

यदि उपयोगकर्ता नकारात्मक संख्या दर्ज करता है, तो एक चेतावनी संदेश प्रकट होता है:

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

एक सामान्य स्थिति में, नियंत्रण प्रयास ब्लॉक के अंत तक पहुंचता है और फिर अंत में ब्लॉक में चला जाता है, जो आवश्यक अंतिम संचालन करता है। यदि नियंत्रण रिटर्न, जारी रखें, या ब्रेक स्टेटमेंट के परिणामस्वरूप प्रयास ब्लॉक से बाहर निकलता है, तो नियंत्रण को कहीं और स्थानांतरित करने से पहले अंततः ब्लॉक निष्पादित किया जाता है।

यदि ट्राई ब्लॉक में कोई अपवाद होता है और इसे संभालने के लिए संबंधित कैच ब्लॉक है, तो नियंत्रण पहले कैच ब्लॉक और फिर अंत में ब्लॉक में जाता है। यदि कोई स्थानीय कैच ब्लॉक नहीं है, तो नियंत्रण पहले अंततः ब्लॉक में जाता है और फिर निकटतम बाहरी कैच ब्लॉक में चला जाता है जो अपवाद को संभाल सकता है।

यदि अंत में ब्लॉक स्वयं रिटर्न, जारी रखें, ब्रेक या थ्रो स्टेटमेंट का उपयोग करके या अपवाद फेंकने वाली विधि को कॉल करके नियंत्रण स्थानांतरित करता है, तो लंबित ट्रांसफर कमांड रद्द कर दिया जाता है और एक नया निष्पादित किया जाता है। उदाहरण के लिए, यदि कोई अंततः ब्लॉक एक अपवाद फेंकता है, तो वह अपवाद किसी भी पहले फेंके गए अपवाद को प्रतिस्थापित कर देगा।

फ़ंक्शन जावास्क्रिप्ट में कोड के सबसे महत्वपूर्ण बिल्डिंग ब्लॉक्स में से एक हैं।

फ़ंक्शंस में आदेशों का एक सेट होता है और आमतौर पर एक विशिष्ट कार्य करते हैं (उदाहरण के लिए, संख्याओं का योग, मूल की गणना करना, आदि)।

किसी फ़ंक्शन में रखा गया कोड केवल इस फ़ंक्शन पर स्पष्ट कॉल के बाद ही निष्पादित किया जाएगा।

1. सिंटेक्स:

//फ़ंक्शन की घोषणा functionFunctionname(ln1, ln2)( function कोड) // functionFunctionname(ln1,lr2) को कॉल करना;

2. सिंटेक्स:

//फ़ंक्शन की घोषणा var function name=function(ln1, ln2)(फ़ंक्शन कोड) //फ़ंक्शन को कॉल करना function name(ln1,lr2);

functionname फ़ंक्शन का नाम निर्दिष्ट करता है। पृष्ठ पर प्रत्येक फ़ंक्शन का एक अद्वितीय नाम होना चाहिए. फ़ंक्शन का नाम लैटिन अक्षरों में निर्दिष्ट होना चाहिए और संख्याओं से शुरू नहीं होना चाहिए।

ln1 और ln2 वेरिएबल या मान हैं जिन्हें फ़ंक्शन के अंदर पारित किया जा सकता है। प्रत्येक फ़ंक्शन में असीमित संख्या में वेरिएबल पास किए जा सकते हैं।

कृपया ध्यान दें: भले ही फ़ंक्शन में कोई वेरिएबल पास न किया गया हो, फ़ंक्शन नाम के बाद कोष्ठक "()" डालना न भूलें।

कृपया ध्यान दें कि जावास्क्रिप्ट में फ़ंक्शन नाम केस संवेदी होते हैं।

नीचे दिए गए उदाहरण में messageWrite() फ़ंक्शन केवल बटन क्लिक करने के बाद ही निष्पादित किया जाएगा।

कृपया ध्यान दें कि यह उदाहरण ऑनक्लिक इवेंट का उपयोग करता है। जावास्क्रिप्ट घटनाएँइस पाठ्यपुस्तक में बाद में विस्तार से चर्चा की जाएगी।

// फ़ंक्शन पेज पर टेक्स्ट लिखता है फ़ंक्शन messageWrite() ( document.write("यह टेक्स्ट जावास्क्रिप्ट का उपयोग करके पेज पर लिखा गया था!"); )

आप फ़ंक्शंस में असीमित संख्या में वेरिएबल पास कर सकते हैं।

कृपया ध्यान दें: फ़ंक्शंस के अंदर वेरिएबल्स पर सभी जोड़-तोड़ वास्तव में वेरिएबल्स पर नहीं, बल्कि उनकी प्रतिलिपि पर किए जाते हैं, इसलिए फ़ंक्शंस निष्पादित करने के परिणामस्वरूप वेरिएबल्स की सामग्री स्वयं नहीं बदलती है।

/*आइए एक फ़ंक्शन को परिभाषित करें जो पारित वेरिएबल में 10 जोड़ता है और पृष्ठ पर परिणाम प्रदर्शित करता है */ फ़ंक्शन प्लस(ए)( ए=ए+10; दस्तावेज़.लिखें("फ़ंक्शन आउटपुट: " + ए+"
"); ) var a=25; document.write("फ़ंक्शन कॉल से पहले वेरिएबल का मान: "+a+"
"); // फ़ंक्शन को वेरिएबल a प्लस(a) पास करके कॉल करें; document.write("फ़ंक्शन को कॉल करने के बाद वेरिएबल का मान: "+a+"
");

त्वरित देखें

किसी फ़ंक्शन की प्रतिलिपि के बजाय उससे वैश्विक वैरिएबल तक पहुंचने के लिए, window.variable_name का उपयोग करें।

फ़ंक्शन प्लस(ए)( window.a=a+10; ) var a=25; document.write("फ़ंक्शन कॉल से पहले वेरिएबल का मान:"+a+"
"); प्लस(ए); document.write("फ़ंक्शन को कॉल करने के बाद वेरिएबल का मान: "+a+"
");

त्वरित देखें

रिटर्न कमांड से आप फ़ंक्शंस से मान वापस कर सकते हैं।

//योग फ़ंक्शन उसे दिए गए वेरिएबल्स का योग लौटाता है फ़ंक्शन sum(v1,v2)( return v1+v2; ) document.write("5+6=" + sum(5,6) + "
"); document.write("10+4=" + योग(10,4) + "
");

त्वरित देखें

उपयोगकर्ता-परिभाषित फ़ंक्शंस के अलावा, जावास्क्रिप्ट में अंतर्निहित फ़ंक्शंस भी हैं।

उदाहरण के लिए, अंतर्निहित isFinite फ़ंक्शन आपको यह जांचने की अनुमति देता है कि पारित मान एक वैध संख्या है या नहीं।

दस्तावेज़.लिखें(isFinite(40)+"
"); document.write(isFinite(-590)+"
"); document.write(isFinite(90.33)+"
"); document.write(isFinite(NaN)+"
"); document.write(isFinite("यह एक स्ट्रिंग है")+"
");

त्वरित देखें

टिप्पणी: पूरी सूचीआप हमारे यहां अंतर्निहित जावास्क्रिप्ट फ़ंक्शंस पा सकते हैं।

फ़ंक्शन के अंदर बनाए गए वेरिएबल को स्थानीय वेरिएबल कहा जाता है। आप ऐसे वेरिएबल्स को केवल उन फ़ंक्शंस के भीतर ही एक्सेस कर सकते हैं जिनमें उन्हें परिभाषित किया गया था।

फ़ंक्शन कोड का निष्पादन पूरा होने के बाद, ऐसे वेरिएबल नष्ट हो जाते हैं। इसका मतलब यह है कि में विभिन्न कार्यसमान नाम वाले वेरिएबल को परिभाषित किया जा सकता है।

फ़ंक्शन कोड के बाहर बनाए गए वेरिएबल्स को ग्लोबल वेरिएबल्स कहा जाता है; ऐसे वेरिएबल्स को कोड में कहीं से भी एक्सेस किया जा सकता है।

यदि आप किसी फ़ंक्शन के अंदर var के बिना एक वेरिएबल घोषित करते हैं, तो यह भी वैश्विक हो जाता है।

पृष्ठ बंद होने के बाद ही वैश्विक चर नष्ट हो जाते हैं।

// वैश्विक चर var1 और var2 घोषित करें var var1='var1 मौजूद है'; वर var2; फ़ंक्शन func1() ( //फ़ंक्शन func1 के अंदर var2 को एक मान निर्दिष्ट करें var var2='var2 मौजूद है"; ) //किसी अन्य फ़ंक्शन से, वेरिएबल var1 और var2 की सामग्री को पेज फ़ंक्शन func2() पर आउटपुट करें ( // वेरिएबल var1 document.write( var1 + " की सामग्री को आउटपुट करें
"); //वेरिएबल var2 document.write(var2); की सामग्री को आउटपुट करें)

त्वरित देखें

ध्यान दें कि जब स्क्रीन पर मुद्रित किया जाता है, तो var2 का मान खाली होगा क्योंकि func1 var2 के स्थानीय "संस्करण" पर काम करता है।

वे फ़ंक्शन जिनमें घोषित होने पर कोई नाम नहीं होता, उन्हें अनाम कहा जाता है।

अनाम फ़ंक्शंस को आमतौर पर नियमित फ़ंक्शंस के रूप में कोड से कॉल करने के लिए नहीं, बल्कि पैरामीटर के रूप में अन्य फ़ंक्शंस में पारित करने के लिए घोषित किया जाता है।

फ़ंक्शन arrMap(arr,func)( var res=new Array; for (var i=0;i target) return null; else return find(start + 5, "(" +story + "+ 5)") || ढूंढें (प्रारंभ * 3, "(" + इतिहास + " * 3)") वापसी खोज(1, "1"); ) कंसोल.लॉग(findSolution(24)); // → (((1 * 3) + 5) * 3)

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

आंतरिक फ़ंक्शन खोज रिकर्सन करता है। इसमें दो तर्क लगते हैं - वर्तमान संख्या और एक स्ट्रिंग जिसमें यह रिकॉर्ड होता है कि हम इस संख्या तक कैसे पहुंचे। और यह या तो हमारे चरणों का क्रम दिखाने वाली एक स्ट्रिंग लौटाता है, या शून्य लौटाता है।

ऐसा करने के लिए, फ़ंक्शन इनमें से एक निष्पादित करता है तीन क्रियाएं. यदि दी गई संख्या लक्ष्य के बराबर है, तो वर्तमान कहानी इसे प्राप्त करने का सटीक तरीका है, इसलिए यह वापस आती है। यदि दी गई संख्या लक्ष्य से बड़ी है, तो गुणा करना और जोड़ना जारी रखने का कोई मतलब नहीं है, क्योंकि यह केवल बढ़ेगा। और यदि हम अभी तक लक्ष्य तक नहीं पहुंचे हैं, तो फ़ंक्शन दिए गए नंबर से शुरू करके दोनों संभावित रास्तों का प्रयास करता है। वह प्रत्येक विधि से स्वयं को दो बार, एक बार बुलाती है। यदि पहली कॉल शून्य नहीं लौटती है, तो वह वापस आ जाती है। दूसरे मामले में, दूसरा वापस कर दिया जाता है।

यह बेहतर ढंग से समझने के लिए कि फ़ंक्शन अपने वांछित प्रभाव को कैसे प्राप्त करता है, आइए संख्या 13 का समाधान खोजने के लिए इसके द्वारा की जाने वाली कॉलों पर नज़र डालें।

ढूंढें(1, "1") ढूंढें(6, "(1 + 5)") ढूंढें(11, "((1 + 5) + 5)") ढूंढें(16, "(((1 + 5) + 5)") ढूंढें ) + 5)") बहुत बड़ी खोज(33, "((((1 + 5) + 5) * 3)") बहुत बड़ी खोज(18, "((1 + 5) * 3)") बहुत बड़ी खोज( 3, "(1 * 3)") ढूंढें(8, "((1 * 3) + 5)") ढूंढें(13, "(((1 * 3) + 5) + 5)") मिला!

इंडेंटेशन कॉल स्टैक की गहराई को दर्शाता है। पहली बार, खोज फ़ंक्शन (1 + 5) और (1 * 3) से शुरू होने वाले समाधानों की जांच करने के लिए खुद को दो बार कॉल करता है। पहली कॉल (1 + 5) से शुरू होने वाले समाधान की तलाश करती है और उन सभी समाधानों की जांच करने के लिए रिकर्सन का उपयोग करती है जो आवश्यक संख्या से कम या उसके बराबर संख्या उत्पन्न करते हैं। वह नहीं मिलता और शून्य लौट आता है। फिर ऑपरेटर || और एक फ़ंक्शन कॉल पर आगे बढ़ता है जो (1 * 3) विकल्प की जांच करता है। हम यहां भाग्यशाली हैं, क्योंकि तीसरी पुनरावर्ती कॉल में हमें 13 मिलते हैं। यह कॉल एक स्ट्रिंग लौटाती है, और प्रत्येक || रास्ते में यह इस रेखा को ऊपर से पार करता है, जिसके परिणामस्वरूप एक समाधान मिलता है।

पहला यह कि आप एक ही तरह का कोड कई बार लिखें. इससे बचना चाहिए - अधिक कोड का मतलब है त्रुटियों के लिए अधिक जगह और प्रोग्राम को समझने की कोशिश करने वालों के लिए अधिक पठन सामग्री। इसलिए हम एक आवर्ती कार्यक्षमता लेते हैं, इसे एक अच्छा नाम देते हैं, और इसे एक फ़ंक्शन में डालते हैं।

दूसरा तरीका यह है कि आपको कुछ नई कार्यक्षमता की आवश्यकता का पता चलता है जो इसमें रखे जाने योग्य है अलग कार्य. आप फ़ंक्शन के नाम से प्रारंभ करें, और फिर उसका मुख्य भाग लिखें। आप उस कोड को लिखकर भी शुरुआत कर सकते हैं जो फ़ंक्शन को परिभाषित करने से पहले फ़ंक्शन का उपयोग करता है।

किसी फ़ंक्शन को नाम देना आपके लिए कितना कठिन है, इससे पता चलता है कि आप इसकी कार्यक्षमता को कितनी अच्छी तरह समझते हैं। चलिए एक उदाहरण लेते हैं. हमें एक प्रोग्राम लिखना होगा जो दो नंबर प्रिंट करेगा, फार्म पर गायों और मुर्गियों की संख्या, उसके बाद "गाय" और "मुर्गियां" शब्द। आपको आगे की संख्याओं में शून्य जोड़ने की आवश्यकता है ताकि प्रत्येक संख्या बिल्कुल तीन स्थान पर हो।

007 गायें 011 मुर्गियाँ

जाहिर है, हमें दो तर्कों वाले एक फ़ंक्शन की आवश्यकता है। आइए कोडिंग शुरू करें.
// फार्म इन्वेंटरी फ़ंक्शन प्रिंट फार्म इन्वेंटरी (गाय, मुर्गियां) प्रिंट करें (var काउस्ट्रिंग = स्ट्रिंग (गाय); जबकि (काउस्ट्रिंग.लेंथ)< 3) cowString = "0" + cowString; console.log(cowString + " Коров"); var chickenString = String(chickens); while (chickenString.length < 3) chickenString = "0" + chickenString; console.log(chickenString + " Куриц"); } printFarmInventory(7, 11);

यदि हम एक स्ट्रिंग में .length जोड़ते हैं, तो हमें इसकी लंबाई मिलती है। यह पता चला है कि while लूप संख्याओं में अग्रणी शून्य जोड़ते हैं जब तक कि उन्हें 3 वर्णों की एक पंक्ति नहीं मिल जाती।

तैयार! लेकिन जैसे ही हम किसान को कोड भेजने वाले थे (एक भारी चेक के साथ), उसने फोन किया और हमें बताया कि उसके खेत में सूअर हैं, और क्या हम सूअरों की संख्या का प्रदर्शन जोड़ सकते हैं कार्यक्रम?

निःसंदेह यह संभव है. लेकिन जब हम इन चार लाइनों से कोड कॉपी और पेस्ट करना शुरू करते हैं, तो हमें एहसास होता है कि हमें रुककर सोचने की जरूरत है। इसके लिए अवश्य ही एक बेहतर तरीका होना चाहिए। ' हम कार्यक्रम को बेहतर बनाने का प्रयास कर रहे हैं:

// शून्य और लेबल फ़ंक्शन जोड़ने के साथ आउटपुट printZeroPaddedWithLabel(number, label) (var numberString = String(number); while (numberString.length)< 3) numberString = "0" + numberString; console.log(numberString + " " + label); } // вывестиИнвентаризациюФермы function printFarmInventory(cows, chickens, pigs) { printZeroPaddedWithLabel(cows, "Коров"); printZeroPaddedWithLabel(chickens, "Куриц"); printZeroPaddedWithLabel(pigs, "Свиней"); } printFarmInventory(7, 11, 3);

काम करता है! लेकिन printZeroPaddedWithLabel नाम थोड़ा अजीब है। यह तीन चीज़ों- आउटपुट, शून्य जोड़ना और एक लेबल- को एक फ़ंक्शन में जोड़ता है। किसी फ़ंक्शन में संपूर्ण दोहराए जाने वाले टुकड़े को सम्मिलित करने के बजाय, आइए एक अवधारणा पर प्रकाश डालें:

// शून्य फ़ंक्शन जीरोपैड (संख्या, चौड़ाई) जोड़ें (var स्ट्रिंग = स्ट्रिंग (संख्या); जबकि (स्ट्रिंग.लंबाई)< width) string = "0" + string; return string; } // вывестиИнвентаризациюФермы function printFarmInventory(cows, chickens, pigs) { console.log(zeroPad(cows, 3) + " Коров"); console.log(zeroPad(chickens, 3) + " Куриц"); console.log(zeroPad(pigs, 3) + " Свиней"); } printFarmInventory(7, 16, 3);

अच्छे, स्पष्ट नाम ज़ीरोपैड वाला एक फ़ंक्शन कोड को समझने में आसान बनाता है। और इसका उपयोग केवल हमारे मामले में ही नहीं, बल्कि कई स्थितियों में किया जा सकता है। उदाहरण के लिए, संख्याओं के साथ स्वरूपित तालिकाएँ प्रदर्शित करना।

सुविधाएँ कितनी स्मार्ट और बहुमुखी होनी चाहिए? हम एक साधारण फ़ंक्शन लिख सकते हैं जो किसी संख्या को तीन स्थानों तक शून्य के साथ पैड करता है, या संख्याओं को फ़ॉर्मेट करने के लिए एक परिष्कृत सामान्य प्रयोजन फ़ंक्शन लिख सकता है जो अंशों, नकारात्मक संख्याओं, डॉट संरेखण, पैडिंग आदि का समर्थन करता है।

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

फ़ार्म उदाहरण में पहला सहायक फ़ंक्शन, printZeroPaddedWithLabel, कहा जाता है क्योंकि इसका एक साइड इफेक्ट होता है: यह एक स्ट्रिंग प्रिंट करता है। दूसरा, ज़ीरोपैड, रिटर्न वैल्यू के कारण। और यह कोई संयोग नहीं है कि दूसरा फ़ंक्शन पहले की तुलना में अधिक बार काम आता है। मान लौटाने वाले फ़ंक्शंस को साइड इफेक्ट उत्पन्न करने वाले फ़ंक्शंस की तुलना में एक-दूसरे के साथ संयोजित करना आसान होता है।

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

हालाँकि, आपको ऐसे फ़ंक्शंस लिखने में शर्मिंदा नहीं होना चाहिए जो पूरी तरह से शुद्ध नहीं हैं, या कोड से ऐसे फ़ंक्शंस का पवित्र शुद्धिकरण शुरू करने में शर्मिंदा नहीं होना चाहिए। दुष्प्रभाव अक्सर फायदेमंद होते हैं। कंसोल.लॉग फ़ंक्शन का साफ़ संस्करण लिखने का कोई तरीका नहीं है, और यह फ़ंक्शन काफी उपयोगी है। कुछ ऑपरेशनों को साइड इफेक्ट्स का उपयोग करके व्यक्त करना आसान होता है।

कार्यों को समझने की कुंजी स्थानीय दायरा है। किसी फ़ंक्शन के अंदर घोषित पैरामीटर और वेरिएबल उसके लिए स्थानीय होते हैं, हर बार कॉल करने पर दोबारा बनाए जाते हैं, और बाहर से दिखाई नहीं देते हैं। किसी अन्य फ़ंक्शन के अंदर घोषित फ़ंक्शन को उसके दायरे तक पहुंच प्राप्त होती है।

किसी प्रोग्राम द्वारा निष्पादित विभिन्न कार्यों को फ़ंक्शंस में अलग करना बहुत उपयोगी है। आपको खुद को दोहराने की ज़रूरत नहीं है; फ़ंक्शंस कोड को सार्थक भागों में विभाजित करके अधिक पठनीय बनाते हैं, जैसे किसी पुस्तक के अध्याय और अनुभाग नियमित पाठ को व्यवस्थित करने में मदद करते हैं।

कंसोल.लॉग(न्यूनतम(0,10)); // → 0 कंसोल.लॉग(न्यूनतम(0, -10)); // → -10

शून्य सम है.
इकाई विषम है.
किसी भी संख्या N की समता N-2 के समान है।

इन नियमों के अनुसार एक पुनरावर्ती फ़ंक्शन isEven लिखें। इसे एक संख्या स्वीकार करनी होगी और एक बूलियन मान लौटाना होगा।

इसे 50 और 75 पर परीक्षण करें। इसे -1 देने का प्रयास करें। वह इस तरह का व्यवहार क्यों कर रही है? क्या इसे किसी तरह ठीक करना संभव है?

50 और 75 पर इसका परीक्षण करें। देखें कि -1 पर यह कैसा व्यवहार करता है। क्यों? क्या आप इसे ठीक करने का कोई तरीका सोच सकते हैं?

कंसोल.लॉग(isEven(50)); // → ट्रू कंसोल.लॉग(isEven(75)); // → गलत कंसोल.लॉग(isEven(-1)); // → ??

किसी स्ट्रिंग की वर्ण संख्या N को उसमें .charAt(N) ("string).charAt(5)) जोड़कर प्राप्त किया जा सकता है - उसी तरह जैसे .length का उपयोग करके स्ट्रिंग की लंबाई प्राप्त की जाती है। वापसी मान एक स्ट्रिंग होगी जिसमें एक वर्ण होगा (उदाहरण के लिए, "k")। स्ट्रिंग के पहले वर्ण की स्थिति 0 है, जिसका अर्थ है कि अंतिम वर्ण की स्थिति स्ट्रिंग होगी। लंबाई - 1। दूसरे शब्दों में, दो वर्णों की एक स्ट्रिंग की लंबाई 2 है, और इसके वर्ण की स्थिति 0 और 1 होगी।

एक फ़ंक्शन countBs लिखें जो एक स्ट्रिंग को एक तर्क के रूप में लेता है और स्ट्रिंग में निहित "बी" वर्णों की संख्या लौटाता है।

फिर काउंटचार नामक एक फ़ंक्शन लिखें, जो कुछ हद तक काउंटबी की तरह काम करता है, लेकिन एक दूसरा पैरामीटर लेता है - वह चरित्र जिसे हम स्ट्रिंग में ढूंढ रहे हैं (सिर्फ "बी" वर्णों की संख्या गिनने के बजाय)। ऐसा करने के लिए, काउंटबी फ़ंक्शन पर दोबारा काम करें।