लोड हो रहा है...

while लूप

int k = 1; किसी भी लूप से पहले 1 रखता है. फिर while (k <= 3) तब तक चलता रहता है जब वह परीक्षा true हो. ब्रेसेस के अंदर, Console.WriteLine(k) वर्तमान संख्या लिखता है, और k = k + 1 k के नीचे एक और रखता है. स्क्रीन तीन पंक्तियाँ दिखाती है: 1, फिर 2, फिर 3. सार्वजनिक कक्षा का नाम Pine रखें.

प्रारंभ बाहर, परीक्षा while में, कदम अंदर

Pine फाइल खोलें. कक्षा का नाम Pine रहता है. यह पृष्ठ प्रकार का नाम नहीं बदलता. अगर for लूप अभी भी हो तो हटाएँ, जिनमें for (int n = 1; n <= 3; n = n + 1) और हर प्रारंभ-परीक्षा-कदम जो एक हेडर में बँधा हो शामिल है. अगर int choice पंक्ति अभी भी हो तो हटाएँ. कोई भी ReadLine पंक्ति भी हटाएँ. जो फाइल आप रखते हैं उसमें टाइप की प्रतीक्षा नहीं, न तीन काम वाले कोष्ठक वाला for हेडर, और न ही switch. स्क्रीन केवल while ब्रेसेस के अंदर की लेखन पंक्ति से लिखी जाती है.

Main के अंदर, पहले काउंटर रखें: int k = 1;. वह पंक्ति while के अंदर नहीं है. वह केवल k को 1 से शुरू करती है. फिर लूप:
while (k <= 3) {
Console.WriteLine(k);
k = k + 1;
}
शब्द while छोटा है. कोष्ठक के अंदर केवल परीक्षा बैठती है: k <= 3. उन कोष्ठक के अंदर प्रारंभ और कदम नहीं हैं — उस for पंक्ति के विपरीत जो आपने पहले देखी. ब्रेसेस लेखन पंक्ति और कदम दोनों रखती हैं. Console.WriteLine(k); वर्तमान संख्या लिखता है और k के चारों ओर उद्धरण नहीं हैं. फिर k = k + 1; k के नीचे एक और रखता है ताकि अगली परीक्षा अंत में false हो सके. फाइल सहेजें.

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

यह शिक्षण आकार रखें. लूप के ऊपर एक रखने वाली पंक्ति, int k = 1;. एक while जिसके कोष्ठक केवल परीक्षा के चारों ओर हों. ब्रेसेस के अंदर एक लेखन पंक्ति. ब्रेसेस के अंदर एक कदम, k = k + 1;. कोई for हेडर नहीं, पिछले पृष्ठ का n काउंटर नहीं, और k के चारों ओर उद्धरण भी नहीं.

k from 1 to 3

csharp

using System;

public class Pine
{
    public static void Main()
    {
        int k = 1;
        while (k <= 3)
        {
            Console.WriteLine(k);
            k = k + 1;
        }
    }
}

ऊपर से पढ़ें. using System; छोटे नाम तैयार करता है. public class Pine प्रकार का नाम देता है. public static void Main() वह जगह है जहाँ रनटाइम शुरू होता है. int k = 1; मान 1 रखता है. while (k <= 3) परीक्षा पूछता है. Console.WriteLine(k); वर्तमान k लिखता है. k = k + 1; काउंटर आगे बढ़ाता है. स्क्रीन पर तीन पंक्तियाँ: 1, फिर 2, फिर 3. जो फाइल आप रखते हैं उसमें for पंक्ति नहीं है.

dotnet run से चलाएँ. कार्यक्रम तीन पंक्तियाँ लिखता है और रुक जाता है. आपके टाइप करने का इंतजार नहीं करता. काउंटर और while पहले से फाइल में थे. अगर dotnet run रुकता है, ReadLine अभी भी फाइल में है. वह पंक्ति हटाएँ और int k = 1; तथा ऊपर वाला while रखें. स्क्रीन 1, फिर 2, फिर 3 दिखाती है. अगर स्क्रीन कभी न रुके और बार-बार 1 लिखे, कदम ब्रेसेस से गायब है. k = k + 1; वापस अंदर लगाएँ. अगर स्क्रीन for-शैली का बचा चलान दिखाए, for हेडर हटाएँ. अगर स्क्रीन हर पंक्ति पर अक्षर k दिखाए, लेखन पंक्ति में उद्धरण हैं: Console.WriteLine("k");. गलत पंक्ति दिखाने वाली स्क्रीन के लिए आप .NET SDK दोबारा इंस्टॉल नहीं करते.

एक पूरा चलान क्रम से चलें. k while से पहले 1 से शुरू होता है. परीक्षा k <= 3 true है, इसलिए बॉडी चलती है: लेखन पंक्ति 1 लिखती है, फिर कदम 2 रखता है. परीक्षा अभी भी true है: 2 लिखती है, 3 रखती है. परीक्षा अभी भी true है: 3 लिखती है, 4 रखती है. अब k <= 3 false है, इसलिए लूप समाप्त होता है. प्रारंभ एक बार, लूप के ऊपर चला. परीक्षा हर पास से पहले चली. कदम ब्रेसेस के अंदर हर लेखन के बाद चला. वे तीन काम वही विचार हैं जो for में हैं, लेकिन एक हेडर पंक्ति में बँधे नहीं हैं. अगर आप k = k + 1; हटा दें और k हमेशा 1 पर रहे, परीक्षा true रहती है और वही पंक्ति बिना रुके लिख सकती है — वही अंतहीन स्थिति इसलिए है कि इस पृष्ठ पर कदम बॉडी के अंदर हो.

परीक्षा बढ़ाएँ

केवल परीक्षा बदलें ताकि लूप एक कदम आगे जाए: while (k <= 4). प्रारंभ और कदम वैसे ही रहने दें. अब स्क्रीन को चार पंक्तियाँ दिखानी चाहिए: 1, 2, 3, और 4.

k from 1 to 4

csharp

using System;

public class Pine
{
    public static void Main()
    {
        int k = 1;
        while (k <= 4)
        {
            Console.WriteLine(k);
            k = k + 1;
        }
    }
}

यह दूसरी फाइल है. जो फाइल आप रखते हैं वह नहीं है. dotnet run चलाएँ. स्क्रीन चार पंक्तियाँ दिखाती है. आपने लेखन पंक्ति या कदम दोबारा नहीं लिखा — केवल while (…) के अंदर की परीक्षा बदली. चार पंक्तियाँ देखने के बाद रखी फाइल वापस लगाएँ: k <= 3 और वही बॉडी. दोनों संस्करण मान्य C# हैं. अलग रुकने के बिंदु के साथ वही while आकार सिखाते हैं.

चार-पंक्ति चलान एक बार फिर पढ़ें. k 1 से शुरू होता है. हर true परीक्षा वर्तमान k लिखती है और फिर 1 जोड़ती है. जब k 5 हो जाता है, परीक्षा असफल होती है और लूप रुकता है. अंक 5 इस डेमो में स्क्रीन पर नहीं आता, क्योंकि बॉडी केवल तब चलती है जब परीक्षा अभी भी true हो.

📊 k and the first demo screen

k before WriteLine	Screen line
1	1
2	2
3	3

तालिका को पहले डेमो के बाद जाँच के रूप में इस्तेमाल करें, चलान की जगह नहीं. उस डेमो में हर लेखन पंक्ति से पहले, k वही संख्या रखता है जो उस पंक्ति पर आएगी. तीसरे लेखन के बाद, कदम 4 रखता है और परीक्षा असफल होती है. अगर बिना कदम वाले संस्करण पर स्क्रीन कभी न रुके, k = k + 1; ब्रेसेस के अंदर वापस लगाएँ — .NET SDK दोबारा इंस्टॉल न करें.

नियम जो while साफ रखते हैं

परीक्षा के चारों ओर कोष्ठक आवश्यक हैं. बिना कोष्ठक के while k <= 3 { … } लिखने पर build त्रुटि लिखता है. इस पृष्ठ की बॉडी हमेशा ब्रेसेस में बैठती है, क्योंकि हर पास में दो पंक्तियाँ हैं: लेखन पंक्ति और कदम. अगर आप कदम बंद ब्रेस के बाद छोड़ दें, वह लूप समाप्त होने के बाद एक बार चलता है — और लूप के अंदर k कभी नहीं बदलता, इसलिए लूप हमेशा चल सकता है. दोनों डेमो में कदम ब्रेसेस के अंदर रखें.

while न तो for है और न ही switch. for प्रारंभ, परीक्षा, और कदम को एक हेडर पंक्ति में बाँधता है. while अपनी हेडर में केवल परीक्षा रखता है और आपसे कहता है कि प्रारंभ और कदम खुद रखें. switch एक बार case लेबलों में से चुनता है. उसी Main में for लूप या switch न छोड़ें और हैरान न हों कि स्क्रीन for-शैली का बचा हेडर या शब्द mid क्यों दिखाती है. इस सत्र के Main में केवल वही int और वही while होना चाहिए.

एक आम उलझन स्वयं वाक्यविन्यास लिखना है: Console.WriteLine("while");. वह वर्ण while लिखता है. दोहराता नहीं. दूसरी उलझन k के चारों ओर उद्धरण लगाना है: Console.WriteLine("k"); हर पास पर अक्षर k लिखता है. जब आप स्क्रीन पर काउंटर चाहते हैं, Console.WriteLine(k) बिना उद्धरण रखें. अगर पहली बार while तक पहुँचते ही परीक्षा पहले से false हो — उदाहरण के लिए k 5 से शुरू हो और परीक्षा कहे k <= 3 — बॉडी कभी नहीं चलती और स्क्रीन खाली रहती है. वह भी मान्य while है; इस पाठ के डेमो ऐसी परीक्षा रखते हैं जो कम से कम एक बार true हो ताकि आप लिखी पंक्तियाँ देख सकें.

अब आप while के ऊपर काउंटर शुरू कर सकते हैं, परीक्षा while (…) में रख सकते हैं, और लेखन पंक्ति तथा कदम दोनों ब्रेसेस के अंदर रख सकते हैं. परीक्षा बदलने से पंक्तियों की संख्या बदलती है. अगला पृष्ठ break और continue है, जहाँ आप लूप से जल्दी निकलते हैं या एक पास छोड़ते हैं बिना पूरे लूप को समाप्त किए.

स्क्रीन बदलता काउंटर है

जो फाइल आप रखते हैं वह 1, फिर 2, फिर 3 लिखती है. नाम k लेखन पंक्ति में है, और अक्षर k स्क्रीन पर नहीं है. प्रारंभ while के ऊपर बैठता है, और स्क्रीन पर नहीं है. k या while के चारों ओर उद्धरण अक्षर लिखते हैं, काउंटर पथ नहीं.

🧠 अपने ज्ञान की परीक्षा करें

शुरू करने के लिए तैयार

अपने ज्ञान की परीक्षा करें

इस इंटरैक्टिव क्विज़ के साथ अपनी चुनौती लें और देखें कि आप विषय को कितनी अच्छी तरह समझते हैं

❓

प्रश्न

🎯

70%

पास करने के लिए

♾️

∞

समय

🔄

∞

प्रयास

📝 निर्देश

हर प्रश्न को ध्यान से पढ़ें
हर प्रश्न के लिए सबसे अच्छा उत्तर चुनें
आप जितनी बार चाहें क्विज़ दोबारा दे सकते हैं
आपकी प्रगति शीर्ष पर दिखाई जाएगी