ब्रेक और जारी बयान के बीच अंतर

Question

क्या कोई मुझे breakऔर continueकथनों के बीच अंतर बता सकता है ?

Answer 1

breakएक पाश छोड़ देता है, continueअगले पुनरावृत्ति के लिए कूदता है।

Comments

ध्यान दें कि जावा में लेबल जारी / टूटने वाले स्टेटमेंट भी होते हैं जिनके अलग-अलग शब्दार्थ होते हैं :-)

— Jay

यह सिर्फ ब्रेक और जारी रखने की मूल बातें है। एक बेहतर स्पष्टीकरण के लिए जे की पोस्ट

— Xn0vv3r

सोच रहे लोगों के लिए, एक लेबल का उपयोग करने के लिए आप एक लूप से पहले ':' के बाद लेबल नाम लिखते हैं।

— Caelum

"ब्रेक" एक स्विच स्टेटमेंट को समाप्त कर देगा

— संस्कार

भले ही यह प्रत्येक लूप के लिए एक और बयान में है, भले ही अगले पुनरावृत्ति के लिए कूद जारी रहेगा?

— klutch

Answer 2

अधिक विवरण और कोड नमूने के लिए ब्रांचिंग विवरण देखें :

break

ब्रेक स्टेटमेंट के दो रूप हैं: लेबल और लेबल रहित। आपने स्विच स्टेटमेंट की पिछली चर्चा में अनलिस्टेड फॉर्म को देखा। तुम भी एक के लिए, जबकि, या करते-करते लूप […]

एक अनबेलिबल ब्रेक स्टेटमेंट अंतरतम स्विच को समाप्त करता है, जबकि, या डू-स्टेटमेंट के लिए, लेकिन एक लेबल ब्रेक बाहरी स्टेटमेंट को समाप्त करता है।

continue

जारी बयान एक, जबकि, या डू-लूप के वर्तमान पुनरावृत्ति को छोड़ देता है। अनलिस्टेड फॉर्म अंतरतम लूप के शरीर के अंत तक पहुंच जाता है और लूप को नियंत्रित करने वाली बूलियन अभिव्यक्ति का मूल्यांकन करता है। [...]

एक लेबल जारी स्टेटमेंट दिए गए लेबल के साथ चिह्नित बाहरी लूप की वर्तमान पुनरावृत्ति को रोक देता है।

Answer 3

System.out.println ("starting loop:");
for (int n = 0; n < 7; ++n)
{
    System.out.println ("in loop: " + n);
    if (n == 2) {
        continue;
    }
    System.out.println ("   survived first guard");
    if (n == 4) {
        break;
    }
    System.out.println ("   survived second guard");
    // continue at head of loop
}
// break out of loop
System.out.println ("end of loop or exit via break");

यह निम्न आउटपुट की ओर ले जाएगा:

starting loop:
in loop: 0
    survived first guard
    survived second guard
in loop: 1
    survived first guard
    survived second guard
in loop: 2
in loop: 3
    survived first guard
    survived second guard
in loop: 4
    survived first guard
end of loop or exit via break

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

first:
for (int i = 0; i < 4; ++i) 
{
    second:
    for (int j = 0; j < 4; ++j) 
    {
        third:
        for (int k = 0; k < 4; ++k) 
        {
            System.out.println ("inner start: i+j+k " + (i + j + k));
            if (i + j + k == 5)
                continue third;
            if (i + j + k == 7)
                continue second;
            if (i + j + k == 8)
                break second;
            if (i + j + k == 9)
                break first;
            System.out.println ("inner stop:  i+j+k " + (i + j + k));
        }
    }       
}

क्योंकि यह संभव है, इसका मतलब यह नहीं है कि आपको इसका उपयोग करना चाहिए।

यदि आप अपने कोड को एक मजाकिया तरीके से बाधित करना चाहते हैं, तो आप एक मतलबी नाम नहीं चुनते हैं, लेकिन http: और इसका अनुसरण एक टिप्पणी के साथ करते हैं, जो स्रोत-कोड में वेबद्रेस की तरह विदेशी दिखता है:

http://stackoverflow.com/questions/462373
for (int i = 0; i < 4; ++i) 
{
     if (i == 2) 
         break http;

मुझे लगता है कि यह एक जोशुआ बलोच क्विज़ल से है। :)

Comments

जुनून के साथ महान विचार, सिर्फ http://stackoverflow.com/questions/462373/काम भी नहीं होगा ?

— Caelum

@ user2104648: हाँ, यह कट 'एन' पेस्ट त्रुटि रही होगी।

— उपयोगकर्ता अज्ञात

Answer 4

ब्रेक लूप को पूरी तरह से छोड़ देता है और लूप के बाद स्टेटमेंट्स को निष्पादित करता है। जबकि जारी वर्तमान पुनरावृत्ति छोड़ता है और लूप में अगले मूल्य के साथ निष्पादित करता है।

यह कोड सब कुछ समझाता है:

public static void main(String[] args) {
    for(int i=0;i<10;i++)
    {
        if (i==4)
        {
            break;
        }
        System.out.print(i+"\t");

    }
    System.out.println();
    for(int i=0;i<10;i++)
    {

        if (i==4)
        {
            continue;
        }
        System.out.print(i+"\t");
    }
}

आउटपुट:

0   1   2   3   
0   1   2   3   5   6   7   8   9

Answer 5

breakपूरी तरह से लूप से बाहर निकलता है। जारीcontinue बयान के बाद बयानों को छोड़ देता है और लूप करता रहता है।

Answer 6

ब्रेक स्टेटमेंट

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

निम्नलिखित उदाहरण में, हम लूप के लिए 0 से 9 तक मानों को प्रिंट करने के लिए एक सरल का उपयोग कर रहे हैं:

for(int i=0; i<10; i++) {
  System.out.println(i);
}

आउटपुट:

0
1
2
3
4
5
6
7
8
9

अब अगर हम i == 4 पर एक ब्रेक स्टेटमेंट जोड़ते हैं, तो हमारा कोड लूप से एक बार टूट जाएगा जब मैं बराबर हो जाएगा। 4. आप लूप्स के लिए ब्रेक आउट का उपयोग कर सकते हैं, जबकि लूप और डू-लूप करते समय। ब्रेक स्टेटमेंट केवल वर्तमान लूप से बाहर निकलेगा। नेस्टेड इनर लूप से बाहरी लूप को तोड़ने के लिए, आपको ब्रेक स्टेटमेंट के साथ लेबल का उपयोग करना होगा।

for(int i=0; i<10; i++) {
  System.out.println(i);
  if(i==4) {
    break;
  }
}

आउटपुट:

0
1
2
3
4

जारी बयान

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

for(int i=0; i<10; i++) {
  if(i==4) {
    continue;
  }
  System.out.println(i);
}

आउटपुट:

0
1
2
3
5 <---- SKIPPED OVER 4 and continued with next loop iteration
6
7
8
9

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

निम्नलिखित उदाहरण 3 छोरों का उपयोग करता है, सभी एक दूसरे के भीतर निहित हैं। चूंकि आंतरिक सबसे अधिक लूप के अंदर से बाहरी सबसे अधिक लूप से पूरी तरह से बाहर निकलने का कोई रास्ता नहीं है, इसलिए हम इसे पूरा करने के लिए "आउट 1" लेबल का उपयोग कर सकते हैं और ब्रेक स्टेटमेंट के बगल में लेबल को निर्दिष्ट कर सकते हैं।

outer1:
for(int i=0; i<5; i++) {
  for(int j=0; j<4; j++) {
    for(int k=0; k<2; k++) {
      System.out.println("[" + i + "][" + j + "][" + k + "]");
      if(j == 3) {
        break outer1;
      }
    }
  }
}

आउटपुट:

[0][0][0]
[0][0][1]
[0][1][0]
[0][1][1]
[0][2][0]
[0][2][1]
[0][3][0]

ध्यान दें कि अंतिम पंक्ति को कैसे प्रदर्शित किया जाता है " 0 [0]" जो कि j == 3 है और जिसे हम "ब्रेक आउट 1" कहते हैं। बाहरी सबसे पाश से बाहर निकलने के लिए।

लूप लेबल - स्टेटमेंट जारी रखें

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

outer1:
for(int i=0; i<5; i++) {
  for(int j=0; j<4; j++) {
    for(int k=0; k<2; k++) {
      System.out.println("[" + i + "][" + j + "][" + k + "]");
      if(j == 3) {
        continue outer1;
    }
  }
}

[0][0][0]
[0][0][1]
[0][1][0]
[0][1][1]
[0][2][0]
[0][2][1]
[0][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[1][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[1][0][1]
[1][1][0]
[1][1][1]
[1][2][0]
[1][2][1]
[1][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[2][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[2][0][1]
[2][1][0]
[2][1][1]
[2][2][0]
[2][2][1]
[2][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[3][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[3][0][1]
[3][1][0]
[3][1][1]
[3][2][0]
[3][2][1]
[3][3][0] <---- CONTINUE WITH LABEL CALLED HERE
[4][0][0] <---- CONTINUES FROM NEXT ITERATION OF OUTER LOOP
[4][0][1]
[4][1][0]
[4][1][1]
[4][2][0]
[4][2][1]
[4][3][0]

स्रोत: जावा में लूप - अंतिम गाइड

Answer 7

उत्कृष्ट उत्तर सरल और सटीक।

मैं एक कोड नमूना जोड़ूंगा।

C:\oreyes\samples\java\breakcontinue>type BreakContinue.java

    class BreakContinue {

        public static void main( String [] args ) {

               for( int i = 0 ; i < 10 ; i++ ) {

                     if( i % 2 == 0) { // if pair, will jump
                         continue; // don't go to "System.out.print" below.
                     }

                     System.out.println("The number is " + i );

                     if( i == 7 ) {
                         break; // will end the execution, 8,9 wont be processed
                      }

               }
        }

    }

C:\oreyes\samples\java\breakcontinue>java BreakContinue
The number is 1
The number is 3
The number is 5
The number is 7

Answer 8

एक breakबयान के परिणामस्वरूप उस कथन की समाप्ति होती है switch, जिस पर यह लागू होता है ( forऔर do, या while)।

continueवर्तमान लूप चलना को समाप्त करने और लूप स्टेटमेंट पर नियंत्रण वापस करने के लिए एक स्टेटमेंट का उपयोग किया जाता है।

Answer 9

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

public static void main(String[] args) {
    for(int i = 0; i < 5; i++){
        if (i == 3) {
            continue;
        }
        System.out.print(i);
    }
}//prints out 0124, continue moves to the next iteration skipping printing 3

public static void main(String[] args) {
    for(int i = 0; i < 5; i++){
        if (i == 3) {
            break;
        }
        System.out.print(i);
    }
}//prints out 012, break moves out of the loop hence doesnt print 3 and 4

Answer 10

निम्नलिखित को धयान मे रखते हुए:

int n;
for(n = 0; n < 10; ++n) {
    break;
}
System.out.println(n);

ब्रेक के कारण लूप समाप्त हो जाता है और n का मान 0 होता है।

int n;
for(n = 0; n < 10; ++n) {
    continue;
}
System.out.println(n);

जारी रखने के कारण प्रोग्राम काउंटर लूप की पहली पंक्ति (स्थिति की जाँच की जाती है और n का मूल्य वर्धन होता है) और n का अंतिम मान 10 है।

यह भी ध्यान दिया जाना चाहिए कि ब्रेक केवल उस लूप के निष्पादन को समाप्त करता है जो इसके भीतर है:

int m;
for(m = 0; m < 5; ++m)
{
    int n;
    for(n = 0; n < 5; ++n) {
        break;
    }
    System.out.println(n);
}
System.out.println(m);

के प्रभाव में कुछ उत्पादन करेगा

0
0
0
0
0
5

Comments

आपको अपने उदाहरणों में परिवर्तनशील परिवर्तनशील समस्याएं मिली हैं।

— दारोन

Answer 11

breakलूप के बाहर बयान टूटता है, (अगले बयान निष्पादित करने के लिए बंद करने ब्रेस के बाद पहले एक है), जबकि continueशुरू होता है अगले चरण में अधिक पाश।

Answer 12

breakबयान वर्तमान पाशन नियंत्रण संरचना मौजूद है और इसके पीछे कूदता है, जबकि continueबाहर निकलता भी लेकिन पाशन हालत के लिए कूद वापस।

Answer 13

सरल उदाहरण:

break पाश छोड़ देता है।

int m = 0;
for(int n = 0; n < 5; ++n){
  if(n == 2){
    break;
  }
  m++;
}

System.out.printl("m:"+m); // m:2

continue पाश शुरू करने के लिए वापस जाना होगा।

int m = 0;
for(int n = 0; n < 5; ++n){
  if(n == 2){
    continue; // Go back to start and dont execute m++
  }
  m++;
}

System.out.printl("m:"+m); // m:4

Answer 14

किसी शर्त को पूरा करने से रोकने के लिए अगर किसी शर्त को पूरा किया जाता है, तो जारी का उपयोग करना चाहिए और यदि किसी शर्त को पूरा किया जाता है तो ब्रेक से बाहर निकलना चाहिए।

उदाहरण के लिए नीचे दिए गए कोड में।

 for(int i=0;i<5;i++){

        if(i==3){

           continue;

        }
       System.out.println(i);
     }

उपरोक्त कोड परिणाम को प्रिंट करेगा: 0 1 2 4

NOw इस कोड पर विचार करें

 for(int i=0;i<5;i++){


            if(i==3){

                break;

            }
            System.out.println(i);
         }

यह कोड 0 1 2 प्रिंट करेगा

जारी रखने और तोड़ने में यही मूल अंतर है।

Answer 15

यहाँ ब्रेक का शब्दार्थ है:

int[] a = new int[] { 1, 3, 4, 6, 7, 9, 10 };
// find 9
for(int i = 0; i < a.Length; i++)
{
    if (a[i] == 9) 
        goto goBreak;

    Console.WriteLine(a[i].ToString());      
}
goBreak:;

यहाँ जारी रखने का शब्दार्थ है:

int[] a = new int[] { 1, 3, 4, 6, 7, 9, 10 };
// skip all odds
for(int i = 0; i < a.Length; i++)
{
    if (a[i] % 2 == 1) 
        goto goContinue;

    Console.WriteLine(a[i].ToString());      

goContinue:;
}

Comments

सी # नहीं है; और जारी रखने के लिए; बयान? मैं इस पर विश्वास नहीं कर सकता।

— ऑस्कररेज़

हाँ C # है, मैं सिर्फ ब्रेक और जारी रखने के शब्दार्थ को समझाता हूं :-)

— माइकल ब्यूं

आप कुछ भी नहीं समझाते हैं, आपने कुछ कोड पोस्ट किए हैं। टिप्पणी कोड भी नहीं। कोड का एक टुकड़ा एक स्पष्टीकरण, या एक 'अर्थ' नहीं है।

— लोर्ने

Answer 16

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

class BreakDemo {
public static void main(String[] args) {

    int[] arrayOfInts = 
        { 32, 87, 3, 589,
          12, 1076, 2000,
          8, 622, 127 };
    int searchfor = 12;

    int i;
    boolean foundIt = false;

    for (i = 0; i < arrayOfInts.length; i++) {
        if (arrayOfInts[i] == searchfor) {
            foundIt = true;
            break;//this is an unlabeled break,an unlabeled break statement terminates the innermost switch,for,while,do-while statement.
        }
    }

    if (foundIt) {
        System.out.println("Found " + searchfor + " at index " + i);
    } else {
        System.out.println(searchfor + " not in the array");
    }
}

एक अनलिस्टेड ब्रेक स्टेटमेंट, अंतरिम स्विच को समाप्त करता है, इसके लिए, जबकि, स्टेटमेंट।

public class BreakWithLabelDemo {
public static void main(String[] args) {
    search:
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 5; j++) {
            System.out.println(i + " - " + j);
            if (j == 3)
                break search;//this is an labeled break.To notice the lab which is search.
        }
    }
}

एक लेबल ब्रेक बाहरी स्टेटमेंट को समाप्त करता है। यदि आप इस डेमो को जावा और जावा देते हैं, तो आपको मिलेगा:

0 - 0
0 - 1
0 - 2
0 - 3

class ContinueDemo {
public static void main(String[] args) {

    String searchMe = "peter piper picked a " + "peck of pickled peppers";
    int max = searchMe.length();
    int numPs = 0;

    for (int i = 0; i < max; i++) {
        // interested only in p's
        if (searchMe.charAt(i) != 'p')
            continue;//this is an unlabeled continue.

        // process p's
        numPs++;
    }
    System.out.println("Found " + numPs + " p's in the string.");
}

एक अनबैलेंस्ड जारी स्टेटमेंट, के लिए वर्तमान पुनरावृत्ति को छोड़ देता है, जबकि, स्टेटमेंट।

public class ContinueWithLabelDemo {
public static void main(String[] args) {
    search:
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 5; j++) {
            System.out.println(i + " - " + j);
            if (j == 3)
                continue search;//this is an labeled continue.Notice the lab which is search
        }
    }
}

एक लेबल जारी स्टेटमेंट, दिए गए lable के साथ चिह्नित बाहरी लूप के वर्तमान पुनरावृत्ति को छोड़ देता है, यदि आप डेमो को जावा और जावा करते हैं, तो आपको मिलेगा:

0 - 0
0 - 1
0 - 2
0 - 3
1 - 0
1 - 1
1 - 2
1 - 3
2 - 0
2 - 1
2 - 2
2 - 3

यदि आपके पास कोई प्रश्न है, तो आप इस का जावा ट्यूटोरियल देख सकते हैं: यहां लिंक विवरण दर्ज करें

Answer 17

सीधे शब्दों में कहें: ब्रेक वर्तमान लूप को समाप्त कर देगा, और लूप समाप्त होने के बाद पहली पंक्ति में निष्पादन जारी रखेगा। लूप की स्थिति में वापस कूदता है और लूप को चालू रखता है।

Comments

लूप के बाद पहले बयान पर।

— लोर्ने

Answer 18

for (int i = 1; i <= 3; i++) {
        if (i == 2) {

            continue;
        }
        System.out.print("[i:" + i + "]");

netbeans में इस कोड को आज़माएं आप ब्रेक और जारी रखने के बीच के अंतर को समझेंगे

for (int i = 1; i <= 3; i++) {
        if (i == 2) {

            break;
        }
        System.out.print("[i:" + i + "]");

Answer 19

जारी रखने और तोड़ने के बीच अंतर को समझने के लिए सरल कार्यक्रम

कब continueइस्तेमाल किया जाता है

    public static void main(String[] args) {
    System.out.println("HelloWorld");
    for (int i = 0; i < 5; i++){
        System.out.println("Start For loop i = " + i);
        if(i==2){
            System.out.println("Inside if Statement for i = "+i);
           continue;
        }
        System.out.println("End For loop i = " + i);
    }
    System.out.println("Completely out of For loop");
}


OutPut:
HelloWorld
Start For loop i = 0
End For loop i = 0
Start For loop i = 1
End For loop i = 1
Start For loop i = 2
Inside if Statement for i = 2
Start For loop i = 3
End For loop i = 3
Start For loop i = 4
End For loop i = 4
Completely out of For loop

कब breakइस्तेमाल किया जाता है

public static void main(String[] args) {
    System.out.println("HelloWorld");
    for (int i = 0; i < 5; i++){
        System.out.println("Start For loop i = " + i);
        if(i==2){
            System.out.println("Inside if Statement for i = "+i);
           break;
        }
        System.out.println("End For loop i = " + i);
    }
    System.out.println("Completely out of For loop");
}

Output:
HelloWorld
Start For loop i = 0
End For loop i = 0
Start For loop i = 1
End For loop i = 1
Start For loop i = 2
Inside if Statement for i = 2
Completely out of For loop

Answer 20

जारी रखें स्टेटमेंट पुनरावृत्ति को रोकें और अगली खुजली शुरू करें Ex:

System.out.println("continue when i is 2:");
    for (int i = 1; i <= 3; i++) {
        if (i == 2) {
            System.out.print("[continue]");
            continue;
        }
        System.out.print("[i:" + i + "]");
    }

और ब्रेक स्टेटमेंट लूप को रोकते हैं या लूप से बाहर निकलते हैं

Answer 21

इसलिए आप लूप के लिए या अंदर हैं। ब्रेक का उपयोग करना; आपको पाश से बाहर कर देगा। जैसे, यह समाप्त हो जाएगा। जारी रखें; इसे अगली यात्रा चलाने के लिए कहेंगे।

का उपयोग करने का कोई मतलब नहीं अगर बयान में जारी है, लेकिन तोड़; उपयोगी है। स्विच ... मामले में, हमेशा ब्रेक का उपयोग करें; किसी मामले को समाप्त करने के लिए, इसलिए यह किसी अन्य मामले को निष्पादित नहीं करता है।

Comments

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

— Sk8erPeter 15

यह न केवल व्यर्थ है, बल्कि अवैध है, जब तक कि ifयह लूप के अंदर नहीं है, इस मामले में बहुत सारे बिंदु हैं।

— लोर्ने