break और continue

i को 1 से 5 तक लूप करें. जब i बराबर 3 हो, लिखने से पहले break से लूप छोड़ दें. स्क्रीन को केवल दो पंक्तियाँ दिखानी चाहिए: 1, फिर 2. वह जल्दी रुकना इस पृष्ठ का एक उपकरण है. दूसरा उपकरण continue है, जो एक पास छोड़ता है और फिर लूप जारी रखता है ताकि 3 न लिखे लेकिन 4 और 5 अभी भी लिखें. सार्वजनिक कक्षा का नाम Pine रखें.

break लूप को जल्दी खत्म करता है

Pine फाइल खोलें. कक्षा का नाम Pine रहता है. यह पृष्ठ प्रकार का नाम नहीं बदलता. अगर अभी भी केवल गिनने वाला सादा while हो तो हटाएँ. अगर जल्दी रुकने वाले if के बिना सादा for हो और आप केवल इस पृष्ठ के डेमो रखना चाहें तो उसे हटाएँ. कोई भी ReadLine पंक्ति भी हटाएँ. जो फाइल आप रखते हैं उसमें टाइप की प्रतीक्षा नहीं, और स्क्रीन केवल उसी लेखन पंक्ति से लिखी जाती है जो तब चलती है जब if false हो.

Main के अंदर, एक for लिखें जो जल्दी रुक सके:
for (int i = 1; i <= 5; i = i + 1) {
if (i == 3) {
break;
}
Console.WriteLine(i);
}
for हेडर वही आकार है जो आप पहले से जानते हैं: प्रारंभ, परीक्षा, कदम. ब्रेसेस के अंदर, एक if पूछता है क्या i बराबर 3 है. जब वह true हो, break; चलता है. break पूरा for लूप एक साथ छोड़ देता है. if के नीचे की लेखन पंक्ति उस पास नहीं चलती, और इस लूप के अंदर i कभी 4 या 5 तक नहीं पहुँचता. जब i 1 या 2 हो, if false है, इसलिए Console.WriteLine(i) संख्या लिखता है. फाइल सहेजें.

जो फाइल आप रखते हैं

यह शिक्षण आकार रखें. 1 से 5 तक एक for. एक if (i == 3) जो break; चलाता है. if के बाद एक लेखन पंक्ति जो नंगे नाम i को लिखती है. जो फाइल आप रखते हैं उसमें continue नहीं है, और break के चारों ओर उद्धरण भी नहीं.

ऊपर से पढ़ें. using System; छोटे नाम तैयार करता है. public class Pine प्रकार का नाम देता है. public static void Main() वह जगह है जहाँ रनटाइम शुरू होता है. for i को 1 से 5 की ओर ले जाता है. जब i 3 हो, break; लूप खत्म करता है. स्क्रीन पर दो पंक्तियाँ: 1, फिर 2. तीसरी पंक्ति नहीं.

dotnet run से चलाएँ. कार्यक्रम दो पंक्तियाँ लिखता है और रुक जाता है. आपके टाइप करने का इंतजार नहीं करता. अगर dotnet run रुकता है, ReadLine अभी भी फाइल में है. वह पंक्ति हटाएँ और ऊपर वाला break वाला for रखें. स्क्रीन 1, फिर 2 दिखाती है. अगर स्क्रीन पाँच पंक्तियाँ दिखाए, break गायब है या if कभी मेल नहीं खाता. अगर स्क्रीन अक्षर break दिखाए, लेखन पंक्ति में उस शब्द के चारों ओर उद्धरण हैं. गलत पंक्ति दिखाने वाली स्क्रीन के लिए आप .NET SDK दोबारा इंस्टॉल नहीं करते.

break चलान क्रम से चलें. i 1 से शुरू होता है. if false है, इसलिए लेखन पंक्ति 1 लिखती है. कदम 2 रखता है. if false है, इसलिए लेखन पंक्ति 2 लिखती है. कदम 3 रखता है. अब i == 3 true है, इसलिए break चलता है और for खत्म होता है. 3, 4, या 5 के लिए कुछ नहीं लिखा जाता. बिना break वाला सादा लूप पाँच पंक्तियाँ लिखता; break दो लेखन के बाद लूप छोटा कर दिया. उस पास पर break के बाद कदम नहीं चलता, और परीक्षा फिर नहीं पूछी जाती, क्योंकि लूप पहले ही खत्म हो चुका है.

continue एक पास छोड़ता है

बॉडी बदलें ताकि continue break की जगह बैठे, और लेखन पंक्ति if के बाद रखें:
for (int i = 1; i <= 5; i = i + 1) {
if (i == 3) {
continue;
}
Console.WriteLine(i);
}
जब i बराबर 3 हो, continue; उस पास का बाकी हिस्सा — लेखन पंक्ति समेत — छोड़ देता है और for कदम तथा अगली परीक्षा पर जाता है. स्वयं लूप खत्म नहीं होता. स्क्रीन को चार पंक्तियाँ दिखानी चाहिए: 1, 2, 4, और 5. खाली जगह वहाँ है जहाँ 3 होता.

यह दूसरी फाइल है. जो फाइल आप रखते हैं वह नहीं है. dotnet run चलाएँ. स्क्रीन चार पंक्तियाँ दिखाती है. आपने for हेडर नहीं बदला — केवल break continue बन गया. चार पंक्तियाँ देखने के बाद रखी फाइल वापस लगाएँ: if के अंदर break. दोनों संस्करण मान्य C# हैं. वे एक ही लूप आकार के अंदर दो अलग जल्दी चालें सिखाते हैं.

continue चलान एक बार फिर पढ़ें. i जाता है 1, 2, 3, 4, 5. 1 और 2 के लिए if false है और संख्याएँ लिखती हैं. 3 के लिए continue लेखन पंक्ति छोड़ता है. 4 और 5 के लिए संख्याएँ फिर लिखती हैं. लूप अभी भी तब सामान्य रूप से रुकता है जब i 6 हो जाए. continue कभी for खत्म नहीं करता; वह केवल एक पास का बाकी हिस्सा छोड़ता है. continue के बाद for अभी भी अपना कदम i = i + 1 चलाता है, इसलिए काउंटर आगे बढ़ता है भले ही उस पास कुछ न लिखा हो.

तालिका को चलान के बाद जाँच के रूप में इस्तेमाल करें, चलान की जगह नहीं. break दो पंक्तियाँ छोड़ता है. continue चार पंक्तियाँ छोड़ता है जिनमें 3 गायब है. अगर आपका मतलब continue था और फिर भी 3 दिखे, लेखन पंक्ति शायद if के ऊपर है — Console.WriteLine(i) को continue के नीचे रखें ताकि छोड़ना उस तक पहुँचे. क्रम ठीक करें, .NET SDK दोबारा इंस्टॉल न करें.

नियम जो दोनों उपकरणों को साफ रखते हैं

break और continue लूप बॉडी के अंदर बैठते हैं. बिना घेरने वाले for या while के Main में अकेले break; लिखने पर build त्रुटि लिखता है. continue; के लिए भी वही है. इस पृष्ठ पर एक if क्षण चुनता है: जब i बराबर 3 हो. बाद में आप अन्य परीक्षाएँ लिख सकते हैं; डेमो i == 3 रखते हैं ताकि स्क्रीन का बदलाव आसानी से दिखे.

break continue नहीं है. break लूप खत्म करता है. continue एक पास छोड़ता है और लूप में रहता है. पिछले पृष्ठ पर switch के अंदर break एक case खत्म करता है; यहाँ घेरने वाली संरचना एक for है. उसी Main में केवल गिनने वाला सादा while, या बिना if वाला सादा for, न छोड़ें और हैरान न हों कि 1 से 5 तक हर संख्या अभी भी क्यों लिखती है. इस सत्र के Main में वही for तथा break या continue वाला if होना चाहिए.

एक आम उलझन स्वयं शब्द लिखना है: Console.WriteLine("break");. वह वर्ण break लिखता है. लूप नहीं रोकता. दूसरी उलझन continue रखने वाले if से पहले Console.WriteLine(i); रखना है, इसलिए 3 अभी भी लिखता है और फिर continue कुछ छोड़े बिना चलता है. दोनों डेमो में लेखन पंक्ति if के बाद रखें. अगर आप बिना घेरने वाले लूप के continue लिखें, build त्रुटि लिखता है; लूप के बाहर अकेले break पर भी वही होता है. इस पाठ के आकार पर ये दोनों शब्द केवल लूप बॉडी के अंदर अर्थ रखते हैं.

अब आप लूप के अंदर break रख सकते हैं ताकि जल्दी निकलें, या continue ताकि एक पास छोड़कर आगे बढ़ें. एक if चुन सकता है कि वह कब हो. अगला पृष्ठ foreach है, जहाँ लूप संग्रह के हर मान पर चलता है बिना प्रारंभ, परीक्षा, और कदम को उसी तरह हाथ से लिखे.

स्क्रीन वही जल्दी चाल है

जो फाइल आप रखते हैं वह 1, फिर 2 लिखती है. शब्द break फाइल में है, और break स्क्रीन पर नहीं है. दूसरी फाइल चार पंक्तियाँ लिखती है जिनमें 3 गायब है. break के चारों ओर उद्धरण अक्षर लिखते हैं, जल्दी रुकना नहीं.