बहाव को काबू करें

Not to be confused with Flow control (data).

कंप्यूटर विज्ञान में, नियंत्रण प्रवाह (या नियंत्रण का प्रवाह) वह क्रम है जिसमें व्यक्तिगत कथन (कंप्यूटर विज्ञान), निर्देश (कंप्यूटर विज्ञान) या अनिवार्य प्रोग्रामिंग कंप्यूटर प्रोग्राम के समारोह कॉल निष्पादन (कंप्यूटिंग) या मूल्यांकन किए जाते हैं। स्पष्ट नियंत्रण प्रवाह पर जोर एक अनिवार्य प्रोग्रामिंग भाषा को घोषणात्मक प्रोग्रामिंग भाषा से अलग करता है।

एक अनिवार्य प्रोग्रामिंग भाषा के भीतर, एक कंट्रोल फ्लो स्टेटमेंट एक ऐसा स्टेटमेंट होता है, जिसके परिणामस्वरूप दो या अधिक रास्तों में से किसका अनुसरण किया जाता है। सख्त प्रोग्रामिंग भाषा के लिए | गैर-सख्त कार्यात्मक भाषाएं, समान परिणाम प्राप्त करने के लिए कार्य और भाषा निर्माण मौजूद हैं, लेकिन उन्हें आमतौर पर नियंत्रण प्रवाह विवरण नहीं कहा जाता है।

बयानों का एक सेट बदले में आम तौर पर एक ब्लॉक (प्रोग्रामिंग) के रूप में संरचित होता है, जो समूहीकरण के अतिरिक्त, एक शाब्दिक दायरे को भी परिभाषित करता है।

बाधा डालना्स और सिग्नल (कंप्यूटिंग) निम्न-स्तरीय तंत्र हैं जो नियंत्रण के प्रवाह को एक सबरूटीन के समान तरीके से बदल सकते हैं, लेकिन आमतौर पर कुछ बाहरी उत्तेजना या घटना (जो अतुल्यकालिक प्रणाली हो सकते हैं) के निष्पादन के बजाय प्रतिक्रिया के रूप में होते हैं। एक इन-लाइन नियंत्रण प्रवाह विवरण।

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

श्रेणियां

प्रवाह चार्ट नियंत्रण प्रवाह दिखा रहा है।

विभिन्न भाषाओं द्वारा समर्थित नियंत्रण प्रवाह कथनों के प्रकार भिन्न होते हैं, लेकिन उनके प्रभाव से वर्गीकृत किया जा सकता है:

• एक अलग बयान पर निरंतरता (बिना शर्त शाखा (कंप्यूटर विज्ञान) या कूद)
• कुछ शर्त पूरी होने पर ही बयानों के एक सेट को निष्पादित करना (पसंद - यानी, सशर्त शाखा)
• बयानों के एक सेट को शून्य या अधिक बार निष्पादित करना, जब तक कि कुछ शर्त पूरी नहीं हो जाती (यानी, लूप - सशर्त शाखा के समान)
• दूर के बयानों का एक सेट निष्पादित करना, जिसके बाद नियंत्रण का प्रवाह आम तौर पर वापस आ जाता है (सबरूटीन्स, कॉरआउट्स और निरंतरता)
• कार्यक्रम को रोकना, किसी और निष्पादन को रोकना (बिना शर्त रोक)

आदिम

लेबल

Main article: Label (computer science)

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

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

<वाक्यविन्यास प्रकाश लैंग = क्यूबेसिक> 10 एलईटी एक्स = 3 20 प्रिंट एक्स </वाक्यविन्यास हाइलाइट>

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

<वाक्यविन्यास प्रकाश लैंग = सी> सफलता: प्रिंटफ (ऑपरेशन सफल रहा। \ n); </वाक्यविन्यास हाइलाइट>

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

गोटो

Main article: GOTO

गोटो स्टेटमेंट (अंग्रेजी शब्दों विक्षनरी का संयोजन: गो और विक्षनरी: टू, और तदनुसार उच्चारित) नियंत्रण के बिना शर्त हस्तांतरण का सबसे बुनियादी रूप है।

यद्यपि कीवर्ड (कंप्यूटिंग) भाषा के आधार पर ऊपरी या निचले मामले में हो सकता है, इसे आमतौर पर इस प्रकार लिखा जाता है:

   'गोटो' लेबल

गोटो स्टेटमेंट का प्रभाव अगले स्टेटमेंट को संकेतित लेबल पर (या तुरंत बाद) प्रदर्शित होने वाले स्टेटमेंट के रूप में निष्पादित करने का कारण बनता है।

गोटो कथनों को कई कंप्यूटर वैज्ञानिकों द्वारा हानिकारक माना गया है, विशेष रूप से एड्जर डब्ल्यू. डिज्कस्ट्रा।

सबरूटीन्स

Main article: Subroutine

सबरूटीन्स के लिए शब्दावली भिन्न होती है; उन्हें वैकल्पिक रूप से दिनचर्या, प्रक्रियाओं, कार्यों (विशेष रूप से यदि वे परिणाम लौटाते हैं) या विधियों के रूप में जाना जा सकता है (विशेषकर यदि वे वर्ग (प्रोग्रामिंग) या प्रकार वर्ग से संबंधित हैं)।

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

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

अनुक्रम

Main article: Structured programming

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

न्यूनतम संरचित नियंत्रण प्रवाह

See also: Structured program theorem

मई 1966 में, बॉम और जैकोपिनी ने एक लेख प्रकाशित किया एसीएम के संचार में, जिसमें दिखाया गया है कि 'गोटो' वाले किसी भी कार्यक्रम को गोटो-मुक्त रूप में परिवर्तित किया जा सकता है जिसमें केवल विकल्प (यदि अन्य हो) और लूप (जबकि स्थिति DO xxx) शामिल है, संभवतः डुप्लिकेट कोड और/या बूलियन के अतिरिक्त के साथ चर (सच्चे/गलत झंडे)। बाद के लेखकों ने दिखाया कि चॉइस को लूप्स (और फिर भी अधिक बूलियन चर) द्वारा प्रतिस्थापित किया जा सकता है।

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

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

कुछ शिक्षाविदों ने बोहम-जैकोपिनी परिणाम के लिए एक शुद्धतावादी दृष्टिकोण अपनाया और तर्क दिया कि निर्देश भी पसंद करते हैं break और return लूप के बीच से निकलना गलत अभ्यास है क्योंकि बोह्म-जैकोपिनी प्रमाण में उनकी आवश्यकता नहीं है, और इस प्रकार उन्होंने वकालत की कि सभी लूपों में एक निकास बिंदु होना चाहिए। यह शुद्धतावादी दृष्टिकोण पास्कल (प्रोग्रामिंग भाषा) (1968-1969 में डिज़ाइन किया गया) भाषा में सन्निहित है, जो 1990 के दशक के मध्य तक शिक्षा में परिचयात्मक प्रोग्रामिंग सिखाने के लिए पसंदीदा उपकरण था। बोहम-जैकोपिनी प्रमेय के सीधे आवेदन के परिणामस्वरूप संरचित चार्ट में अतिरिक्त स्थानीय चर पेश किए जा सकते हैं, और इसके परिणामस्वरूप कुछ कोड दोहराव भी हो सकते हैं। पास्कल इन दोनों समस्याओं से प्रभावित है और एरिक एस रॉबर्ट्स द्वारा उद्धृत अनुभवजन्य अध्ययनों के अनुसार, छात्र प्रोग्रामरों को पास्कल में कई सरल समस्याओं के लिए सही समाधान तैयार करने में कठिनाई हुई, जिसमें एक सरणी में एक तत्व खोजने के लिए एक फ़ंक्शन लिखना शामिल था। रॉबर्ट्स द्वारा उद्धृत हेनरी शापिरो द्वारा 1980 के एक अध्ययन में पाया गया कि केवल पास्कल-प्रदत्त नियंत्रण संरचनाओं का उपयोग करते हुए, सही समाधान केवल 20% विषयों द्वारा दिया गया था, जबकि किसी भी विषय ने इस समस्या के लिए गलत कोड नहीं लिखा था, यदि उन्हें रिटर्न लिखने की अनुमति दी गई थी। एक पाश के बीच।

व्यवहार में नियंत्रण संरचनाएं

नियंत्रण संरचनाओं वाली अधिकांश प्रोग्रामिंग भाषाओं में एक प्रारंभिक कीवर्ड होता है जो शामिल नियंत्रण संरचना के प्रकार को इंगित करता है। भाषाएँ तब विभाजित होती हैं कि नियंत्रण संरचनाओं के पास अंतिम कीवर्ड है या नहीं।

• कोई अंतिम कीवर्ड नहीं: ALGOL 60, C (प्रोग्रामिंग लैंग्वेज), C++, हास्केल (प्रोग्रामिंग भाषा), Java (प्रोग्रामिंग लैंग्वेज), पास्कल (प्रोग्रामिंग लैंग्वेज), पर्ल, PHP, PL/I, पायथन (प्रोग्रामिंग लैंग्वेज), पावरशेल ऐसी भाषाओं को एक साथ बयानों को समूहीकृत करने के कुछ तरीकों की आवश्यकता होती है:
  • एल्गोल 60 और पास्कल: begin ... end
  • सी, सी ++, जावा, पर्ल, पीएचपी, और पावरशेल: घुंघराले ब्रैकेट प्रोग्रामिंग भाषा { ... }
  • पीएल/आई: DO ... END
  • पायथन: इंडेंट स्टाइल स्तर का उपयोग करता है (ऑफ-साइड नियम देखें)
  • हास्केल: या तो इंडेंट स्टाइल लेवल या कर्ली ब्रैकेट का उपयोग किया जा सकता है, और उन्हें स्वतंत्र रूप से मिश्रित किया जा सकता है
  • लुआ: उपयोग करता है do ... end
• अंतिम कीवर्ड: एडा (प्रोग्रामिंग भाषा), एल्गोल 68, मॉड्यूल-2, फोरट्रान 77, Mythryl, मूल दृश्य final कीवर्ड के रूप भिन्न होते हैं:
  • अदा: अंतिम कीवर्ड है end + स्थान + आरंभिक कीवर्ड उदा., if ... end if, loop ... end loop
  • ALGOL 68, Mythryl: आरंभिक कीवर्ड की वर्तनी पीछे की ओर लिखी जाती है उदा., if ... fi, case ... esac
  • फोरट्रान 77: अंतिम कीवर्ड है END + प्रारंभिक कीवर्ड उदा., IF ... ENDIF, DO ... ENDDO
  • मोडुला -2: वही अंतिम कीवर्ड END प्रत्येक वस्तु के लिए
  • विज़ुअल बेसिक: प्रत्येक नियंत्रण संरचना का अपना कीवर्ड होता है। If ... End If; For ... Next; Do ... Loop; While ... Wend

पसंद

अगर-तब-(और) कथन

Main article: Conditional (computer programming)

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

• IF..GOTO. असंरचित भाषाओं में पाया जाने वाला एक फॉर्म, एक विशिष्ट मशीन कोड निर्देश की नकल करते हुए, शर्त पूरी होने पर एक लेबल या लाइन नंबर पर कूद जाएगा।
• IF..THEN..(ENDIF). कूदने तक सीमित होने के बजाय, कोई भी साधारण कथन या नेस्टेड ब्लॉक, THEN कुंजी कीवर्ड का अनुसरण कर सकता है। यह एक संरचित रूप है।
• IF..THEN..ELSE..(ENDIF). ऊपर के रूप में, लेकिन अगर स्थिति झूठी है तो दूसरी कार्रवाई की जाएगी। यह कई रूपों के साथ सबसे आम रूपों में से एक है। कुछ को टर्मिनल की आवश्यकता होती है ENDIF, अन्य नहीं करते। C (प्रोग्रामिंग लैंग्वेज) और संबंधित भाषाओं के लिए टर्मिनल कीवर्ड या 'फिर' की आवश्यकता नहीं होती है, लेकिन शर्त के चारों ओर कोष्ठक की आवश्यकता होती है।
• सशर्त बयान हो सकते हैं और अक्सर अन्य सशर्त बयानों के अंदर नेस्टेड होते हैं। कुछ भाषाएँ अनुमति देती हैं ELSE और IF में जोड़ा जाना है ELSEIF, की एक श्रृंखला होने की आवश्यकता से बचना ENDIF या मिश्रित कथन के अंत में अन्य अंतिम कथन।

Pascal:	Ada:	C:	Shell script:	Python:	Lisp:
if a > 0 then writeln("yes") else writeln("no");	if a > 0 then Put_Line("yes"); else Put_Line("no"); end if;	if (a > 0) { puts("yes"); } else { puts("no"); }	if [ $a -gt 0 ]; then echo "yes" else echo "no" fi	if a > 0: print("yes") else: print("no")	(princ (if (plusp a) "yes" "no"))

कम सामान्य विविधताओं में शामिल हैं:

• कुछ भाषाओं, जैसे कि फोरट्रान, में तीन-तरफ़ा या अंकगणितीय if होता है, परीक्षण करता है कि क्या एक संख्यात्मक मान धनात्मक, ऋणात्मक या शून्य है।
• कुछ भाषाओं में a का कार्यात्मक प्रोग्रामिंग रूप होता है if कथन, उदाहरण के लिए लिस्प (प्रोग्रामिंग भाषा) | लिस्प का cond.
• कुछ भाषाओं में a का एक ऑपरेटर (प्रोग्रामिंग) रूप होता है if स्टेटमेंट, जैसे C का टर्नरी ऑपरेटर।
• पर्ल एक सी-शैली का पूरक है if साथ when और unless.
• स्मॉलटॉक उपयोग करता है ifTrue और ifFalse किसी मौलिक भाषा के निर्माण के बजाय सशर्त को लागू करने के लिए संदेश।

केस और स्विच स्टेटमेंट

Main article: Switch statement

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

Pascal:	Ada:	C:	Shell script:	Lisp:
case someChar of 'a': actionOnA; 'x': actionOnX; 'y','z':actionOnYandZ; else actionOnNoMatch; end;	case someChar is when 'a' => actionOnA; when 'x' => actionOnX; when 'y' | 'z' => actionOnYandZ; when others => actionOnNoMatch; end;	switch (someChar) { case 'a': actionOnA; break; case 'x': actionOnX; break; case 'y': case 'z': actionOnYandZ; break; default: actionOnNoMatch; }	case $someChar in a) actionOnA ;; x) actionOnX ;; [yz]) actionOnYandZ ;; *) actionOnNoMatch ;; esac	(case some-char ((#\a) action-on-a) ((#\x) action-on-x) ((#\y #\z) action-on-y-and-z) (else action-on-no-match))

लूप्स

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

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

गणना-नियंत्रित लूप

Main article: For loop

अधिकांश प्रोग्रामिंग भाषाओं में लूप को एक निश्चित संख्या में दोहराने के लिए निर्माण होते हैं। ज्यादातर मामलों में गिनती ऊपर की बजाय नीचे की ओर जा सकती है और 1 के अलावा अन्य स्टेप साइज का उपयोग किया जा सकता है।

   I के लिए = 1 से N | I := 1 से N के लिए शुरू करते हैं
       XXX | xxx
   अगला मैं | अंत;
--------------------------------------------------- ----------
   डीओ आई = 1, एन | के लिए (मैं = 1; मैं <= एन; ++ मैं) {
       XXX | xxx
   अंत करो | }

इन उदाहरणों में, यदि एन <1 तो प्रोग्रामिंग भाषा के आधार पर लूप का शरीर एक बार निष्पादित हो सकता है (मेरे पास मूल्य 1 है) या बिल्कुल नहीं।

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

   X के लिए := 0.1 स्टेप 0.1 से 1.0 करें

राउंडिंग त्रुटियों और/या हार्डवेयर और/या कंपाइलर संस्करण के आधार पर 9 या 10 बार दोहराया जा सकता है। इसके अलावा, यदि एक्स की वृद्धि बार-बार जोड़ से होती है, तो संचयी राउंडिंग त्रुटियों का अर्थ हो सकता है कि प्रत्येक पुनरावृत्ति में एक्स का मान अपेक्षित अनुक्रम 0.1, 0.2, 0.3, ..., 1.0 से काफी भिन्न हो सकता है।

स्थिति-नियंत्रित लूप

Main articles: While loop and Do while loop

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

   DO WHILE (परीक्षण) | दोहराना
       XXX | xxx
   पाश | परीक्षण तक;
------------------------------------------------------------
   जबकि (परीक्षण) { | करना
       XXX | xxx
   } | जबकि (परीक्षण);

एक नियंत्रण विराम एक मूल्य परिवर्तन का पता लगाने की विधि है जिसका उपयोग साधारण लूप के भीतर मूल्यों के समूहों के लिए प्रसंस्करण को ट्रिगर करने के लिए किया जाता है। मानों को लूप के भीतर मॉनिटर किया जाता है और एक परिवर्तन प्रोग्राम प्रवाह को उनसे जुड़े समूह ईवेंट के प्रबंधन में बदल देता है।

   तब तक करें (फ़ाइल का अंत)
      अगर नया-ज़िपकोड <> वर्तमान-ज़िपकोड
         डिस्प्ले_टैली (वर्तमान-ज़िपकोड, ज़िपकाउंट)
         
         वर्तमान-ज़िपकोड = नया-ज़िपकोड
         जिपकाउंट = 0
      अगर अंत
      
      जिपकाउंट++
   फंदा

संग्रह-नियंत्रित लूप

Main article: Foreach

कई प्रोग्रामिंग लैंग्वेज (जैसे, एडा (प्रोग्रामिंग लैंग्वेज), डी (प्रोग्रामिंग भाषा), सी ++ 11, स्मॉलटॉक, पीएचपी, पर्ल, वस्तु पास्कल, जावा (प्रोग्रामिंग लैंग्वेज), सी शार्प (प्रोग्रामिंग लैंग्वेज) | सी #, MATLAB, विज़ुअल बेसिक, रूबी (प्रोग्रामिंग भाषा), पायथन (प्रोग्रामिंग लैंग्वेज), जावास्क्रिप्ट, फोरट्रान 95 और बाद के संस्करण) में विशेष निर्माण होते हैं जो एक सरणी के सभी तत्वों, या एक सेट या संग्रह के सभी सदस्यों के माध्यम से अंतर्निहित लूपिंग की अनुमति देते हैं।

   someCollection करते हैं: [:eachElement |xxx].

   संग्रह में आइटम के लिए xxx अंत शुरू करें;

   foreach (आइटम; myCollection) {xxx}

   foreach someArray {xxx}

   foreach ($ someArray as $k => $v) {xxx}

   संग्रह <स्ट्रिंग> कॉल; के लिए (स्ट्रिंग एस: कॉल) {}

   foreach (myStringCollection में स्ट्रिंग एस) {xxx}

   कुछ संग्रह | प्रत्येक वस्तु के लिए {$_}

   forall (सूचकांक = पहला: अंतिम: चरण ...)

स्काला (प्रोग्रामिंग भाषा) में स्काला (प्रोग्रामिंग लैंग्वेज) # फॉर-एक्सप्रेशन | फॉर-एक्सप्रेशन हैं, जो संग्रह-नियंत्रित लूप को सामान्य करते हैं, और अन्य उपयोगों का भी समर्थन करते हैं, जैसे कि अतुल्यकालिक प्रोग्रामिंग। हास्केल (प्रोग्रामिंग लैंग्वेज) में डू-एक्सप्रेशन और कॉम्प्रिहेंशन हैं, जो एक साथ स्काला में फॉर-एक्सप्रेशन के समान कार्य प्रदान करते हैं।

सामान्य पुनरावृत्ति

सामान्य पुनरावृति रचनाएँ जैसे C's for बयान और सामान्य लिस्प do उपरोक्त किसी भी प्रकार के लूप और अन्य को व्यक्त करने के लिए फॉर्म का उपयोग किया जा सकता है, जैसे समानांतर में कुछ संग्रहों पर लूपिंग। जहां अधिक विशिष्ट लूपिंग निर्माण का उपयोग किया जा सकता है, यह आमतौर पर सामान्य पुनरावृति निर्माण पर पसंद किया जाता है, क्योंकि यह अक्सर अभिव्यक्ति के उद्देश्य को स्पष्ट करता है।

अनंत लूप

Main article: Infinite loop

अनंत लूप का उपयोग प्रोग्राम सेगमेंट लूप को हमेशा के लिए या एक असाधारण स्थिति उत्पन्न होने तक सुनिश्चित करने के लिए किया जाता है, जैसे कि त्रुटि। उदाहरण के लिए, एक घटना-संचालित कार्यक्रम (जैसे कि एक सर्वर (कंप्यूटिंग)) को हमेशा के लिए लूप करना चाहिए, घटनाओं को संभालते हुए, केवल तभी रुकना चाहिए जब एक ऑपरेटर द्वारा प्रक्रिया को समाप्त कर दिया जाए।

अन्य नियंत्रण प्रवाह निर्माणों का उपयोग करके अनंत लूपों को लागू किया जा सकता है। आमतौर पर, असंरचित प्रोग्रामिंग में यह जम्प बैक अप (गोटो) होता है, जबकि संरचित प्रोग्रामिंग में यह एक अनिश्चित लूप (जबकि लूप) होता है जो कभी भी समाप्त नहीं होता है, या तो स्थिति को छोड़ कर या स्पष्ट रूप से इसे सही पर सेट करके, जैसा कि while (true) .... कुछ भाषाओं में अनंत लूप के लिए विशेष निर्माण होते हैं, आमतौर पर अनिश्चित लूप से स्थिति को छोड़ कर। उदाहरणों में शामिल हैं एडा (loop ... end loop), फोरट्रान (DO ... END DO), जाओ (for { ... }), और रूबी (loop do ... end).

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

अगले पुनरावृत्ति के साथ निरंतरता

कभी-कभी लूप के शरीर के भीतर शेष लूप बॉडी को छोड़ने और लूप के अगले पुनरावृत्ति के साथ जारी रखने की इच्छा होती है। कुछ भाषाएँ एक कथन प्रदान करती हैं जैसे continue (अधिकांश भाषाएं), skip, या next (पर्ल और रूबी), जो यह करेगा। प्रभाव अंतरतम लूप बॉडी को समय से पहले समाप्त करना है और फिर अगले पुनरावृत्ति के साथ सामान्य रूप से फिर से शुरू करना है। यदि पुनरावृत्ति लूप में अंतिम है, तो प्रभाव पूरे लूप को जल्दी समाप्त करना है।

वर्तमान पुनरावृत्ति फिर से करें

कुछ भाषाएँ, जैसे पर्ल और रूबी, लीजिये redo बयान जो वर्तमान पुनरावृत्ति को प्रारंभ से पुनरारंभ करता है।

लूप को पुनरारंभ करें

रूबी के पास है retry बयान जो पूरे लूप को प्रारंभिक पुनरावृत्ति से पुनरारंभ करता है।

छोरों से जल्दी बाहर निकलें

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

निम्नलिखित उदाहरण एडा (प्रोग्रामिंग भाषा) में किया गया है जो लूप से जल्दी बाहर निकलने और बीच में परीक्षण के साथ नियंत्रण प्रवाह#लूप दोनों का समर्थन करता है। दोनों विशेषताएं बहुत समान हैं और दोनों कोड स्निपेट्स की तुलना करने से अंतर दिखाई देगा: प्रारंभिक निकास को 'if' कथन के साथ जोड़ा जाना चाहिए, जबकि बीच की स्थिति एक स्व-निहित निर्माण है।

<वाक्यविन्यास लैंग = एडीए> Ada.Text IO के साथ; Ada.Integer टेक्स्ट IO के साथ;

प्रक्रिया Print_Squares है

   एक्स : पूर्णांक;

शुरू

   Read_Data : लूप
       Ada.Integer टेक्स्ट IO.Get(X);
   Read_Data से बाहर निकलें जब X = 0;
       Ada.Text IO.Put (X * X);
       Ada.Text IO.New_Line;
   अंत पाश Read_Data;

अंत Print_Squares; </वाक्यविन्यास हाइलाइट>

पायथन (प्रोग्रामिंग लैंग्वेज) कोड के सशर्त निष्पादन का समर्थन करता है, जो इस बात पर निर्भर करता है कि लूप जल्दी निकल गया था (a break बयान) या लूप के साथ एक और खंड का उपयोग करके नहीं। उदाहरण के लिए,

<वाक्यविन्यास लैंग = अजगर> n के लिए set_of_numbers में:

   अगर प्राइम (एन) है:
       प्रिंट (सेट में एक अभाज्य संख्या है)
       तोड़ना

अन्य:

   प्रिंट (सेट में कोई अभाज्य संख्या नहीं है)

</वाक्यविन्यास हाइलाइट> else उपरोक्त उदाहरण में e> खंड से जुड़ा हुआ है for कथन, और आंतरिक नहीं if बयान। दोनों पायथन for और while लूप ऐसे अन्य क्लॉज का समर्थन करते हैं, जिसे केवल तभी निष्पादित किया जाता है जब लूप का जल्दी निकास नहीं हुआ हो।

कुछ भाषाएँ नेस्टेड लूप्स को तोड़ने का समर्थन करती हैं; सैद्धान्तिक हलकों में, इन्हें बहु-स्तरीय विराम कहा जाता है। एक सामान्य उपयोग उदाहरण बहु-आयामी तालिका खोज रहा है। यह या तो मल्टीलेवल ब्रेक (एन लेवल से ब्रेक आउट) के माध्यम से किया जा सकता है, जैसा कि बैश में होता है और पीएचपी, या जावा और पर्ल के रूप में लेबल ब्रेक के माध्यम से (दिए गए लेबल पर ब्रेक आउट और जारी रखें)। मल्टीलेवल ब्रेक के विकल्पों में सिंगल ब्रेक शामिल हैं, साथ में एक स्टेट वेरिएबल जिसे दूसरे लेवल को ब्रेक आउट करने के लिए टेस्ट किया जाता है; अपवाद, जो टूट जाने के स्तर पर पकड़े जाते हैं; नेस्टेड लूप को एक फंक्शन में रखना और पूरे नेस्टेड लूप के प्रभाव को समाप्त करने के लिए रिटर्न का उपयोग करना; या एक लेबल और गोटो स्टेटमेंट का उपयोग करना। सी में एक बहुस्तरीय विराम शामिल नहीं है, और सामान्य विकल्प एक लेबल वाले विराम को लागू करने के लिए एक गोटो का उपयोग करना है। पायथन में बहुस्तरीय विराम या जारी नहीं है - यह PEP 3136 में प्रस्तावित किया गया था, और इस आधार पर खारिज कर दिया गया था कि अतिरिक्त जटिलता इसके लायक नहीं थी दुर्लभ वैध उपयोग। बहु-स्तरीय विराम की धारणा सैद्धांतिक कंप्यूटर विज्ञान में कुछ रुचि रखती है, क्योंकि यह आज कोसरजू पदानुक्रम कहलाती है। 1973 में एस. राव कोसाराजू ने संरचित कार्यक्रम प्रमेय को परिष्कृत करते हुए यह साबित किया कि संरचित प्रोग्रामिंग में अतिरिक्त चर जोड़ने से बचना संभव है, जब तक कि मनमाना-गहराई, लूप से बहु-स्तरीय विराम की अनुमति है। इसके अलावा, कोसरजू ने साबित किया कि कार्यक्रमों का एक सख्त पदानुक्रम मौजूद है: प्रत्येक पूर्णांक n के लिए, एक प्रोग्राम मौजूद होता है जिसमें गहराई का एक बहु-स्तरीय विराम होता है, जिसे एक प्रोग्राम के रूप में फिर से नहीं लिखा जा सकता है, जो बिना जोड़े गए n से कम गहराई के बहु-स्तरीय विराम के साथ होता है। चर।

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

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

लूप वेरिएंट और इनवेरिएंट

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

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

कुछ प्रोग्रामिंग लैंग्वेज, जैसे एफिल (प्रोग्रामिंग लैंग्वेज) में लूप वेरिएंट और इनवेरिएंट के लिए मूल समर्थन होता है। अन्य मामलों में, समर्थन एक ऐड-ऑन है, जैसे जावा में लूप स्टेटमेंट के लिए जावा मॉडलिंग भाषा की विशिष्टता (प्रोग्रामिंग भाषा)।

लूप उपभाषा

कुछ लिस्प (प्रोग्रामिंग भाषा) बोलियाँ लूप्स का वर्णन करने के लिए एक व्यापक उपभाषा प्रदान करती हैं। एक प्रारंभिक उदाहरण इंटरलिस्प के रूपांतरण लिस्प में पाया जा सकता है। सामान्य लिस्प एक लूप मैक्रो प्रदान करता है जो ऐसी उपभाषा लागू करता है।

लूप सिस्टम क्रॉस-रेफरेंस टेबल

Programming language	conditional			loop				early exit	loop continuation	redo	retry	correctness facilities
	begin	middle	end	count	collection	general	infinite					variant	invariant
Ada	Yes	Yes	Yes	Yes	arrays	No	Yes	deep nested	No
APL	Yes	No	Yes	Yes	Yes	Yes	Yes	deep nested	Yes	No	No
C	Yes	No	Yes	No	No	Yes	No	deep nested	deep nested	No
C++	Yes	No	Yes	No	Yes	Yes	No	deep nested	deep nested	No
C#	Yes	No	Yes	No	Yes	Yes	No	deep nested	deep nested
COBOL	Yes	No	Yes	Yes	No	Yes	No	deep nested	deep nested	No
Common Lisp	Yes	Yes	Yes	Yes	builtin only	Yes	Yes	deep nested	No
D	Yes	No	Yes	Yes	Yes	Yes	Yes	deep nested	deep nested	No
Eiffel	Yes	No	No	Yes	Yes	Yes	No	one level	No	No	No	integer only	Yes
F#	Yes	No	No	Yes	Yes	No	No	No	No	No
FORTRAN 77	Yes	No	No	Yes	No	No	No	one level	Yes
Fortran 90	Yes	No	No	Yes	No	No	Yes	deep nested	Yes
Fortran 95 and later	Yes	No	No	Yes	arrays	No	Yes	deep nested	Yes
Haskell	No	No	No	No	Yes	No	Yes	No	No	No
Java	Yes	No	Yes	No	Yes	Yes	No	deep nested	deep nested	No		non-native	non-native
JavaScript	Yes	No	Yes	No	Yes	Yes	No	deep nested	deep nested	No
Natural	Yes	Yes	Yes	Yes	No	Yes	Yes	Yes	Yes	Yes	No
OCaml	Yes	No	No	Yes	arrays,lists	No	No	No	No	No
PHP	Yes	No	Yes	No	Yes	Yes	No	deep nested	deep nested	No
Perl	Yes	No	Yes	No	Yes	Yes	No	deep nested	deep nested	Yes
Python	Yes	No	No	No	Yes	No	No	deep nested	deep nested	No
REBOL	No	Yes	Yes	Yes	Yes	No	Yes	one level	No	No
Ruby	Yes	No	Yes	Yes	Yes	No	Yes	deep nested	deep nested	Yes	Yes
Standard ML	Yes	No	No	No	arrays,lists	No	No	No	No	No
Visual Basic .NET	Yes	No	Yes	Yes	Yes	No	Yes	one level per type of loop	one level per type of loop
PowerShell	Yes	No	Yes	No	Yes	Yes	No	?	Yes

1. ^a while (true) इस उद्देश्य के लिए अनंत लूप के रूप में नहीं गिना जाता है, क्योंकि यह एक समर्पित भाषा संरचना नहीं है।
2. ^{a b c d e f g h} सी for (init; test; increment) लूप एक सामान्य लूप निर्माण है, विशेष रूप से एक गिनती नहीं है, हालांकि इसका उपयोग अक्सर इसके लिए किया जाता है।
3. ^{a b c} लेबल और गोटो के उपयोग के माध्यम से APL, C, C++ और C# में डीप ब्रेक प्राप्त किए जा सकते हैं।
4. ^a PHP 5 में ऑब्जेक्ट्स पर इटरेशन जोड़ा गया था।
5. ^{a b c} एक वृद्धिशील सूची या जनरेटर पर पुनरावृति करके एक गिनती लूप का अनुकरण किया जा सकता है, उदाहरण के लिए, पायथन range().
6. ^{a b c d e} एक्सेप्शन हैंडलिंग के उपयोग के माध्यम से डीप ब्रेक्स को पूरा किया जा सकता है।
7. ^a कोई विशेष निर्माण नहीं है, क्योंकि while इसके लिए फंक्शन का इस्तेमाल किया जा सकता है।
8. ^a कोई विशेष निर्माण नहीं है, लेकिन उपयोगकर्ता सामान्य लूप कार्यों को परिभाषित कर सकते हैं।
9. ^a सी++11 मानक ने सी++11#रेंज-बेस्ड फॉर लूप|रेंज-बेस्ड फॉर की शुरुआत की। मानक टेम्पलेट लाइब्रेरी में, एक है std::for_each टेम्प्लेट (प्रोग्रामिंग) फ़ंक्शन जो एसटीएल कंटेनर (डेटा संरचना) पर पुनरावृति कर सकता है और प्रत्येक तत्व के लिए एक एकात्मक समारोह को कॉल कर सकता है। कार्यक्षमता को सी प्रीप्रोसेसर # मैक्रो परिभाषा और इन कंटेनरों पर विस्तार के रूप में भी बनाया जा सकता है।
10. ^a गणना-नियंत्रित लूपिंग एक पूर्णांक अंतराल में पुनरावृत्ति द्वारा प्रभावित होती है; बाहर निकलने के लिए एक अतिरिक्त शर्त शामिल करके जल्दी बाहर निकलें।
11. ^a एफिल एक आरक्षित शब्द का समर्थन करता है retry, हालांकि इसका उपयोग अनुबंध द्वारा डिज़ाइन के आधार पर अपवाद हैंडलिंग # अपवाद हैंडलिंग में किया जाता है, लूप नियंत्रण नहीं।
12. ^a Java मॉडलिंग लैंग्वेज (JML) बिहेवियरल इंटरफ़ेस स्पेसिफिकेशंस लैंग्वेज की आवश्यकता है।
13. ^a पूर्णांक होने के लिए लूप वेरिएंट की आवश्यकता होती है; ट्रांसफिनिट वेरिएंट समर्थित नहीं हैं। [1]
14. ^a डी अनंत संग्रहों का समर्थन करता है, और उन संग्रहों पर पुनरावृति करने की क्षमता। इसके लिए किसी विशेष रचना की आवश्यकता नहीं है।
15. ^a डीप ब्रेक का उपयोग करके प्राप्त किया जा सकता है GO TO और प्रक्रियाएं।
16. ^a सामान्य लिस्प सामान्य संग्रह प्रकार की अवधारणा से पहले का है।

संरचित गैर-स्थानीय नियंत्रण प्रवाह

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

शर्तें

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

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

दुर्भाग्य से, कुछ कार्यान्वयनों में स्थान और समय (विशेष रूप से SUBSCRIPTRANGE) दोनों में पर्याप्त ओवरहेड था, इसलिए कई प्रोग्रामर ने शर्तों का उपयोग करने से बचने की कोशिश की।

सामान्य सिंटैक्स उदाहरण:

 'ऑन' कंडीशन 'गोटो' लेबल

अपवाद

Main article: Exception handling

आधुनिक भाषाओं में अपवाद से निपटने के लिए एक विशेष संरचित निर्माण होता है जो के उपयोग पर निर्भर नहीं करता है GOTO या (बहु-स्तरीय) टूट जाता है या वापस आ जाता है। उदाहरण के लिए, सी ++ में कोई लिख सकता है:

<वाक्यविन्यास लैंग = सीपीपी> कोशिश {

   xxx1 // यहीं कहीं
   xxx2 // उपयोग करें: कुछ वैल्यू फेंकें;
   xxx3

} कैच (कुछ क्लास और कुछ आईडी) {// कुछ क्लास का मूल्य पकड़ें

   एक्शनफॉरसम क्लास

} कैच (कुछ टाइप और अन्य आईडी) {// कुछ टाइप का मूल्य पकड़ें

   एक्शनफॉरसम टाइप

} पकड़ो (...) {// कुछ भी पकड़ो जो पहले से पकड़ा नहीं गया है

   कार्रवाई कुछ भी और के लिए

} </वाक्यविन्यास हाइलाइट>

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

C++ के प्रभाव से, catch आज के समय में लोकप्रिय अन्य भाषाओं जैसे जावा या C# में पैटर्न-मिलान अपवाद हैंडलर घोषित करने के लिए आरक्षित कीवर्ड है। Ada जैसी कुछ अन्य भाषाएँ कीवर्ड का उपयोग करती हैं exception एक अपवाद हैंडलर पेश करने के लिए और फिर एक अलग कीवर्ड भी नियोजित कर सकता है (when Ada में) पैटर्न मिलान के लिए। अपवाद होने पर AppleScript जैसी कुछ भाषाएँ अपवाद हैंडलर सिंटैक्स में प्लेसहोल्डर्स को स्वचालित रूप से जानकारी के कई टुकड़े निकालने के लिए शामिल करती हैं। इस दृष्टिकोण का उदाहरण नीचे दिया गया है on error AppleScript से निर्माण: <वाक्यविन्यास लैंग = एप्सस्क्रिप्ट> कोशिश

   myNumber को myNumber / 0 पर सेट करें

त्रुटि ई संख्या एन पर एफ से टी आंशिक परिणाम पीआर

   अगर (ई = शून्य से विभाजित नहीं हो सकता) तो संवाद प्रदर्शित करें आपको ऐसा नहीं करना चाहिए

अंत प्रयास </वाक्यविन्यास हाइलाइट>

डेविड वाट की 2004 की पाठ्यपुस्तक भी सीक्वेंसर के ढांचे में अपवाद प्रबंधन का विश्लेषण करती है (इस लेख में लूप से शुरुआती निकास पर अनुभाग में पेश किया गया)। वाट नोट करता है कि एक असामान्य स्थिति, आमतौर पर अंकगणित अतिप्रवाह या इनपुट/आउटपुट विफलताओं जैसे फ़ाइल नहीं मिली, एक प्रकार की त्रुटि है जो कुछ निम्न-स्तरीय प्रोग्राम इकाई में पाई जाती है, लेकिन [जिसके लिए] एक हैंडलर अधिक स्वाभाविक रूप से स्थित होता है एक उच्च स्तरीय कार्यक्रम इकाई। उदाहरण के लिए, एक प्रोग्राम में फ़ाइलों को पढ़ने के लिए कई कॉल हो सकते हैं, लेकिन जब कोई फ़ाइल नहीं मिलती है तो कार्रवाई करने के लिए प्रोग्राम के प्रश्न में फ़ाइल के अर्थ (उद्देश्य) पर निर्भर करता है और इस प्रकार इस असामान्य स्थिति के लिए एक हैंडलिंग रूटीन नहीं हो सकता निम्न-स्तरीय सिस्टम कोड में स्थित है। वॉट्स आगे नोट करता है कि कॉलर में स्टेटस फ्लैग परीक्षण शुरू करना, सिंगल-एग्जिट स्ट्रक्चर्ड प्रोग्रामिंग या यहां तक ​​​​कि (मल्टी-एग्जिट) रिटर्न सीक्वेंसर के रूप में, ऐसी स्थिति में परिणाम होगा जहां एप्लिकेशन कोड स्टेटस फ्लैग के परीक्षणों से अव्यवस्थित हो जाता है और यह कि प्रोग्रामर स्थिति ध्वज का परीक्षण करने के लिए भूल गए या आलसी हो सकते हैं। वास्तव में, स्टेटस फ़्लैग द्वारा दर्शाई गई असामान्य स्थितियों को डिफ़ॉल्ट रूप से नज़रअंदाज़ कर दिया जाता है! वाट नोट करता है कि स्टेटस फ्लैग परीक्षण के विपरीत, अपवादों में विपरीत डिफ़ॉल्ट (कंप्यूटर विज्ञान) होता है, जिससे प्रोग्राम समाप्त हो जाता है जब तक कि प्रोग्रामर स्पष्ट रूप से किसी तरह से अपवाद से निपटता है, संभवतः इसे अनदेखा करने के लिए स्पष्ट कोड जोड़कर। इन तर्कों के आधार पर, वाट ने निष्कर्ष निकाला कि जम्प सीक्वेंसर या एस्केप सीक्वेंसर ऊपर चर्चा किए गए शब्दार्थ के साथ एक समर्पित अपवाद सीक्वेंसर के रूप में उपयुक्त नहीं हैं। ऑब्जेक्ट पास्कल, डी, जावा, सी#, और पायथन ए में finally धारा में जोड़ा जा सकता है try निर्माण। कोई फर्क नहीं पड़ता कि कैसे नियंत्रण छोड़ देता है try कोड अंदर finally क्लॉज को निष्पादित करने की गारंटी है। कोड लिखते समय यह उपयोगी होता है जो प्रसंस्करण समाप्त होने पर एक महंगे संसाधन (जैसे खुली फ़ाइल या डेटाबेस कनेक्शन) को त्यागना चाहिए:

<वाक्यविन्यास प्रकाश लैंग = csharp> फाइलस्ट्रीम एसटीएम = शून्य; // सी # उदाहरण प्रयत्न {

   stm = नया फ़ाइलस्ट्रीम (logfile.txt, FileMode.Create);
   वापसी प्रक्रिया स्टफ (एसटीएम); // एक अपवाद फेंक सकता है

} आखिरकार {

   अगर (एसटीएम! = शून्य)
       stm.Close ();

} </वाक्यविन्यास हाइलाइट>

चूँकि यह पैटर्न काफी सामान्य है, C# में एक विशेष सिंटैक्स है:

<वाक्यविन्यास प्रकाश लैंग = csharp> का उपयोग (var stm = new FileStream (logfile.txt, FileMode.Create)) {

   वापसी प्रक्रिया स्टफ (एसटीएम); // एक अपवाद फेंक सकता है

} </वाक्यविन्यास हाइलाइट>

छोड़ने पर using-ब्लॉक, कंपाइलर गारंटी देता है कि stm ऑब्जेक्ट जारी किया जाता है, फ़ाइल को प्रारंभ करने और जारी करने के साइड इफेक्ट्स से अलग करते हुए चर को फ़ाइल स्ट्रीम में प्रभावी रूप से नाम दें। अजगर का with कथन और रूबी का ब्लॉक तर्क File.open समान प्रभाव के लिए प्रयुक्त होते हैं।

ऊपर उल्लिखित सभी भाषाएँ मानक अपवादों और उन परिस्थितियों को परिभाषित करती हैं जिनमें उन्हें फेंका जाता है। उपयोगकर्ता अपने स्वयं के अपवादों को फेंक सकते हैं; वास्तव में सी ++ उपयोगकर्ताओं को मूल प्रकार सहित लगभग किसी भी प्रकार को फेंकने और पकड़ने की अनुमति देता है int, जबकि जावा जैसी अन्य भाषाएँ अनुज्ञेय नहीं हैं।

निरंतरता

Main article: Continuation

अतुल्यकालिक

सी # 5.0 ने प्रत्यक्ष शैली में एसिंक्रोनस I/O का समर्थन करने के लिए async कीवर्ड पेश किया।

जेनरेटर

जेनरेटर (कंप्यूटर विज्ञान), जिसे सेमीकॉरटीन्स के रूप में भी जाना जाता है, अस्थायी रूप से एक उपभोक्ता विधि को नियंत्रित करने की अनुमति देता है, आमतौर पर एक का उपयोग करके yield कीवर्ड (उपज विवरण)। async कीवर्ड की तरह, यह डायरेक्ट स्टाइल में प्रोग्रामिंग का समर्थन करता है।

कॉरआउट्स

कोरूटाइन ऐसे कार्य हैं जो एक दूसरे पर नियंत्रण प्राप्त कर सकते हैं - बिना थ्रेड के सहकारी मल्टीटास्किंग का एक रूप।

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

गैर-स्थानीय नियंत्रण प्रवाह क्रॉस संदर्भ

Programming language	conditions	exceptions	generators/coroutines	async
Ada	No	Yes	?	?
C	No	No	No	No
C++	No	Yes	Yes	?
C#	No	Yes	Yes	Yes
COBOL	Yes	Yes	No	No
Common Lisp	Yes	No	?	?
D	No	Yes	Yes	?
Eiffel	No	Yes	?	?
Erlang	No	Yes	Yes	?
F#	No	Yes	Yes	Yes
Go	No	Yes	Yes	?
Haskell	No	Yes	Yes	No
Java	No	Yes	No	No
JavaScript	?	Yes	Yes	Yes
Objective-C	No	Yes	No	?
PHP	No	Yes	Yes	?
PL/I	Yes	No	No	No
Python	No	Yes	Yes	Yes
REBOL	Yes	Yes	No	?
Ruby	No	Yes	Yes	via extension
Rust	No	Yes	experimental	Yes
Scala	No	Yes	via experimental extension	via experimental extension
Tcl	via traces	Yes	Yes	via event loop
Visual Basic .NET	Yes	Yes	No	?
PowerShell	No	Yes	No	?

प्रस्तावित नियंत्रण संरचनाएं

एक स्पूफ डाटामेशन लेख में 1973 में, आर. लॉरेंस क्लार्क ने सुझाव दिया कि GOTO कथन को COMEFROM कथन द्वारा प्रतिस्थापित किया जा सकता है, और कुछ मनोरंजक उदाहरण प्रदान करता है। COMEFROM को INTERCAL नाम की एक गूढ़ प्रोग्रामिंग भाषा में लागू किया गया था।

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

बीच में परीक्षण के साथ लूप

1972 में ओले-जोहान डाहल द्वारा निम्नलिखित प्रस्तावित किया गया था: पाश पाश

       xxx1 पढ़ें (चार);
   परीक्षण करते समय; जबकि EndOfFile पर नहीं;
       xxx2 राइट (चार);
   दोहराना; दोहराना;

यदि xxx1 को छोड़ दिया जाता है, तो हमें शीर्ष पर परीक्षण के साथ एक लूप मिलता है (पारंपरिक जबकि लूप)। यदि xxx2 को छोड़ दिया जाता है, तो हमें तल पर परीक्षण के साथ एक लूप मिलता है, जो कई भाषाओं में do while लूप के बराबर होता है। यदि while को छोड़ दिया जाता है, तो हमें एक अनंत लूप प्राप्त होता है। यहां के निर्माण को बीच में चेक के साथ डू लूप के रूप में सोचा जा सकता है। इसलिए यह एकल निर्माण अधिकांश प्रोग्रामिंग भाषाओं में कई निर्माणों को प्रतिस्थापित कर सकता है।

इस निर्माण की कमी वाली भाषाएं आम तौर पर एक समान अनंत-लूप-विथ-ब्रेक मुहावरे का उपयोग करके इसका अनुकरण करती हैं:

जबकि (सच) {
    xxx1
    अगर (परीक्षण नहीं)
        तोड़ना
    xxx2
}

एक संभावित संस्करण परीक्षण के दौरान एक से अधिक की अनुमति देना है; लूप के भीतर, लेकिन एग्जिट व्हेन (अगला खंड देखें) का उपयोग इस मामले को बेहतर ढंग से कवर करने के लिए प्रतीत होता है।

Ada (प्रोग्रामिंग लैंग्वेज) में, उपरोक्त लूप निर्माण (लूप-जबकि-दोहराना) को एक मानक अनंत लूप (लूप-एंड लूप) का उपयोग करके दर्शाया जा सकता है, जिसमें बीच में क्लॉज होने पर एक्जिट होता है (एग्जिट व्हेन स्टेटमेंट के साथ भ्रमित नहीं होना चाहिए) निम्नलिखित खंड में)।

<वाक्यविन्यास लैंग = एडीए> Ada.Text_IO के साथ; Ada.Integer_Text_IO के साथ;

प्रक्रिया Print_Squares है

   एक्स : पूर्णांक;

शुरू

   Read_Data : लूप
       Ada.Integer_Text_IO.Get (एक्स);
   Read_Data से बाहर निकलें जब X = 0;
       Ada.Text IO.Put (X * X);
       Ada.Text IO.New_Line;
   अंत पाश Read_Data;

अंत Print_Squares; </वाक्यविन्यास हाइलाइट>

एक लूप का नामकरण (इस उदाहरण में रीड_डाटा की तरह) वैकल्पिक है लेकिन कई नेस्टेड लूप के बाहरी लूप को छोड़ने की अनुमति देता है।

नेस्टेड लूप से एकाधिक प्रारंभिक निकास/निकास

यह 1974 में ज़हन के निर्माण द्वारा प्रस्तावित किया गया था। इसका संशोधित रूप यहां प्रस्तुत है।

   बाहर निकलें जब इवेंटए या इवेंटबी या इवेंटसी;
       xxx
   बाहर निकलता है
       इवेंट ए: एक्शन ए
       इवेंट बी: एक्शन बी
       इवेंट सी: एक्शन सी
   एंडेक्सिट;

एक्सिटजब का उपयोग उन घटनाओं को निर्दिष्ट करने के लिए किया जाता है जो xxx के भीतर हो सकती हैं, घटना के नाम को एक बयान के रूप में उपयोग करके उनकी घटना का संकेत दिया जाता है। जब कोई घटना घटित होती है, तो प्रासंगिक कार्रवाई की जाती है, और फिर अंत के ठीक बाद नियंत्रण पास हो जाता है। यह निर्माण यह निर्धारित करने के बीच एक बहुत स्पष्ट अलगाव प्रदान करता है कि कुछ स्थिति लागू होती है, और उस स्थिति के लिए की जाने वाली कार्रवाई।

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

निम्नलिखित सरल उदाहरण में किसी विशेष वस्तु के लिए द्वि-आयामी तालिका खोजना शामिल है।

   बाहर निकलें जब पाया या गायब;
       for I := 1 to N do
           J के लिए := 1 से M करें
               अगर टेबल [आई, जे] = लक्ष्य तो मिला;
       गुम;
   बाहर निकलता है
       मिला: प्रिंट (आइटम तालिका में है);
       लापता: प्रिंट (आइटम तालिका में नहीं है);
   एंडेक्सिट;

सुरक्षा

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

यह भी देखें

• शाखा (कंप्यूटर विज्ञान)
• नियंत्रण प्रवाह विश्लेषण | नियंत्रण-प्रवाह विश्लेषण
• नियंत्रण-प्रवाह आरेख
• नियंत्रण-प्रवाह ग्राफ
• नियंत्रण तालिका
• कोरूटिन
• साइक्लोमेटिक कम्पलेक्सिटी
• अजगर|ड्रैकन-चार्ट
• फ़्लोचार्ट
• के लिए जाओ
• जीरो, नियंत्रण संरचनाओं को सीखने में मदद करता है
• मुख्य घेरा
• प्रत्यावर्तन
• निर्धारण (कंप्यूटिंग)
• स्पेगेटी कोड
• संरचित प्रोग्रामिंग
• सबरूटीन
• स्विच स्टेटमेंट, सशर्त रूप से प्रवाह को नियंत्रित करता है

अग्रिम पठन

• Hoare, C. A. R. "Partition: Algorithm 63," "Quicksort: Algorithm 64," and "Find: Algorithm 65." Comm. ACM 4, 321-322, 1961.

बाहरी कड़ियाँ

• Media related to बहाव को काबू करें at Wikimedia Commons
• Go To Statement Considered Harmful
• A Linguistic Contribution of GOTO-less Programming
• "Structured Programming with Go To Statements" (PDF). Archived from the original (PDF) on 2009-08-24. (2.88 MB)
• "IBM 704 Manual" (PDF). (31.4 MB)