जावास्क्रिप्ट लूप के लिए फ़ंक्शन चला रहा है। चक्र और पुनरावृत्ति। लूप के लिए तोड़ना

सही चक्र - वास्तविकता का प्रतिबिंब

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

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

लूप के लिए अनंत

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

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

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

बयान जारी रखें और तोड़ें

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

सरल एल्गोरिदम का विशाल संयोजन

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

एक बार फिर, हम कम जगह में अधिक जानकारी व्यक्त करते हैं। हमारी खोज का उपयोग करते हुए, किसी विशेष प्रविष्टि को खोजने का हमारा कार्य केवल एक प्रश्न पर उबलता है: हमें कैसे पता चलेगा कि हमें वह मिल गया है जो हम चाहते हैं? पुनरावृत्ति कैसे होती है, इसके विवरण के बारे में हमें चिंता करने की आवश्यकता नहीं है।

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

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

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

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

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

पोस्टकंडीशन के साथ लूप

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

जावास्क्रिप्ट में लूप के प्रकार, लूप नियंत्रण

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

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

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

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

कोई कारण नहीं है कि आप 0 से शुरू करते हैं और फिर ऊपर की ओर बढ़ते हैं। आपने सुना होगा कि ऐसा कुछ करने से आपके लूप की परफॉर्मेंस बेहतर हो जाती है। जूरी अभी भी बाहर है कि क्या वेतन वृद्धि की तुलना में कमी तेजी से होगी, लेकिन आप प्रयोग कर सकते हैं और देख सकते हैं कि क्या आपको कोई प्रदर्शन लाभ दिखाई देता है।

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

भले ही, पूर्णता के हित में, आइए उन दोनों पर एक नज़र डालते हैं। प्रत्येक पुनरावृत्ति के साथ, हमारा लूप गिनती मान को 1 से बढ़ाता है। अभी, आप यह नहीं देख सकते हैं कि आप लूप का बहुत उपयोग कर रहे हैं। यदि आपके पास इस या किसी अन्य विषय के बारे में कोई प्रश्न है, तो सबसे आसान काम यह है कि आप ऐसे मित्रवत लोगों का समूह बताएं जो आपकी मदद करने में प्रसन्न होंगे!

कोड स्थान में जावास्क्रिप्ट की स्थिति

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

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

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

• यह अभिव्यक्ति चर भी घोषित कर सकती है।
• दशा अभिव्यक्ति व्यक्त की जा रही है।
• यदि शर्त मान सत्य है, तो लूप स्टेटमेंट निष्पादित किए जाते हैं।

लूप के लिए तोड़ना

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

लूप में स्टेटमेंट निष्पादित होने से पहले कंडीशन चेक किया जाता है। सुनिश्चित करें कि लूप में स्थिति अंततः झूठी हो जाती है; अन्यथा, लूप कभी खत्म नहीं होगा। एक लेबल एक पहचानकर्ता के साथ एक बयान प्रदान करता है जो इसे आपके कार्यक्रम में कहीं और संदर्भित करने की अनुमति देता है।