जावास्क्रिप्ट में जबकि और करते समय के बीच का अंतर

Michael Zippo

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

यह ट्यूटोरियल की मूल बातों पर चर्चा करेगा। जबकि और do ... जबकि Java निर्देश और कुछ उदाहरण जावा प्रोग्राम में इन निर्देशों को प्रदर्शित करने के लिए प्रस्तुत किए जाएंगे।

Java जबकि

जबकि कोड के एक ब्लॉक में तब तक लूप करता है जब तक कि कोई निर्दिष्ट शर्त सही न हो। जबकि लूप का सिंटैक्स एक पारंपरिक स्टेटमेंट के समान है। यहाँ जावा सिंटैक्स जबकि लूप है:

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

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

हम एक कैलेंडर बनाना चाहते हैं जो हमें बताए कि कितने लोग पहले से टेबल ऑर्डर कर सकते हैं . उन्हें प्रतीक्षा सूची में डालने के लिए। हम इसे इस तरह से एक जबकि लूप का उपयोग करके कर सकते हैं जो लूप के शरीर को तब तक चलाएगा जब तक कि पारित आदेशों की संख्या सीमा से कम न हो:

हमारा कोड रिटर्न:

डाउनटाइम हमारे कोड को तोड़ता है। पहली पंक्ति में हम limit नामक एक वेरिएबल घोषित करते हैं जो अधिकतम संख्या का ट्रैक रखता है टेबलों की संख्या हम बना सकते हैं। इसके बाद, हम orders_made नामक एक वैरिएबल घोषित करते हैं जो रखे गए ऑर्डर की संख्या को संग्रहीत करता है

हमारा प्रोग्राम तब एक जबकि लूप चलता है, जिसे orders_made के दौरान निष्पादित किया जाता है। कोड> सीमा से कम है। इसलिए, हम orders_made++ इंक्रीमेंट ऑपरेटर का उपयोग orders_made में 1 जोड़ने के लिए करते हैं।

इन्क्रीमेंट ऑपरेटर के निष्पादित होने के बाद, हमारा प्रोग्राम शेष की गणना करता है "orders_made को limit से घटाकर टेबल की क्षमता। फिर संदेश को प्रिंट करें [क्षमता] आप कई टेबल सॉर्ट कर सकते हैं। कंसोल पर।< br>

हमारा "जबकि" स्टेटमेंट काम करना बंद कर देता है जब orders_made लिमिट से ज्यादा हो।

Java Do while

do ... जबकि लूप फिर लूप का एक प्रकार है do .. जबकि लूप में कोड के ब्लॉक को निष्पादित करता है >एक बार जाँच करें कि क्या कोई स्टेट आयन सत्य का मूल्यांकन करता है। फिर प्रोग्राम तब तक लूप को दोहराएगा जब तक कि स्थिति सही है।

जबकि और करते हैं ... जबकि लूप यह है कि जबकि लूप पहले की स्थिति का मूल्यांकन करते हैं जबकि ब्लॉक में कोड निष्पादित करते हैं , जबकि do ... के बाद स्थिति का मूल्यांकन करें। कोड को do ब्लॉक

डू के सिंटैक्स में निष्पादित करके ... जबकि लूप इस प्रकार है:

हम उपयोग कर रहे हैं यह कैसे करना है यह समझाने के लिए एक उदाहरण ... सब कुछ एक लूप में काम करता है।

मान लीजिए कि हम एक पहेली बनाते हैं जो उपयोगकर्ता को एक और दस के बीच की संख्या का अनुमान लगाने के लिए कहता है। हम चाहते हैं कि हमारे उपयोगकर्ता को पहले यह देखने के लिए एक नंबर के लिए कहा जाए कि क्या उन्होंने सही संख्या का अनुमान लगाया है। यदि उपयोगकर्ता गलत नंबर दर्ज करता है, तो उन्हें फिर से प्रयास करने के लिए पदोन्नत किया जाना चाहिए। हम इसे do ... जबकि लूप का उपयोग करके कर सकते हैं।

यहां एक प्रोग्राम का उदाहरण दिया गया है जो उपयोगकर्ता से किसी संख्या का अनुमान लगाने के लिए कहता है, फिर मूल्यांकन करता है कि उपयोगकर्ता ने do का उपयोग करके सही संख्या का अनुमान लगाया है या नहीं। .. लूप:

 जब हम अपना कोड चलाते हैं, तो हमें प्राइम  की संख्या का अनुमान लगाने के लिए कहा जाता है, हमारे do ... जबकि  कोड> चक्र का मूल्यांकन किया जाता है। जब आप अंत में सही अंक का अनुमान लगाने से पहले कुछ अंकों का अनुमान लगाने का प्रयास करते हैं तो यहां क्या होता है:
 हमारे कोड के उतरने का विराम। सबसे पहले, हम util.Scanner आयात करते हैं, जिसका उपयोग उपयोगकर्ता इनपुट एकत्र करने के लिए किया जाता है। इसके बाद, हम GuessingGame नामक एक वर्ग को परिभाषित करते हैं जिसमें हमारा कोड मौजूद होता है

  फिर हम दो चर परिभाषित करते हैं: एक नाम number जो अनुमान लगाने के लिए संख्या को संग्रहीत करता है, और दूसरा नाम अनुमान जो उपयोगकर्ताओं के अनुमान को संग्रहीत करता है।
अगला, हम उपयोगकर्ता इनपुट शुरू करने के लिए स्कैनर विधि का उपयोग करें। हम संदेश को प्रिंट करते हैं 1 और 10 के बीच एक संख्या दर्ज करें: कंसोल पर, फिर input.nextInt () का उपयोग करके पुनः प्राप्त करें उपयोगकर्ता द्वारा दर्ज की गई संख्या 
।
इस कोड के निष्पादित होने के बाद, do ... जबकि लूप मूल्यांकन करता है कि उपयोगकर्ता द्वारा अनुमानित संख्या उस संख्या के बराबर है जिसे उपयोगकर्ता को अनुमान लगाना चाहिए। यदि उपयोगकर्ता ने अनुमान लगाया है गलत संख्या, do लूप की सामग्री फिर से चलाई जाती है; यदि u ser ने सही संख्या का अनुमान लगाया, do ... जबकि लूप निष्पादन को रोक देता है और संदेश आप सही कह रहे हैं!  कंसोल पर प्रिंट होता है।
पूर्ण लूप में 
 अनंत लूप लूप होते हैं जो हमेशा काम करते रहेंगे। यदि आपके पास एक जबकि लूप है जिसकी घोषणा झूठी नहीं लौटती है, तो लूप जारी रहेगा और आपके प्रोग्राम को क्रैश कर सकता है। इसलिए, यह सुनिश्चित करना महत्वपूर्ण है कि किसी बिंदु पर जबकि लूप काम करना बंद कर देता है
यहां जावा में अनंत लूप का एक उदाहरण दिया गया है।
 यह लूप अंतहीन चलेगा। हालाँकि, हम पॉज़  स्टेटमेंट का उपयोग करके अपने प्रोग्राम को रोक सकते हैं। मान लीजिए कि हम एक प्रोग्राम बना रहे हैं जो उपलब्ध तालिकाओं की संख्या का ट्रैक रखता है। हमारे पास स्टॉक में केवल पांच पेंटिंग हैं। जब स्टॉक में कोई टेबल नहीं होती है, तो हम चाहते हैं कि हमारा जबकि लूप रुक जाए। हम निम्नलिखित कोड का उपयोग करके एक प्रोग्राम बना सकते हैं जो इन विनिर्देशों को पूरा करता है: