सी # लूप - ब्रेक बनाम जारी रखें

सी # में (अन्य भाषाओं के लिए उत्तर देने में संकोच न करें) लूप, लूप के बीच क्या अंतर है और लूप की संरचना को छोड़ने के साधन के रूप में जारी है, और अगले पुनरावृत्ति पर जाएं?

उदाहरण:

foreach (DataRow row in myTable.Rows)
{
    if (someConditionEvalsToTrue)
    {
        break; //what's the difference between this and continue ?
        //continue;
    }
}
0
ro fr bn
जारी रखें; वर्तमान पंक्ति की प्रसंस्करण को रोक देगा और संग्रह से अगली पंक्ति जारी रखेगा। दूसरी ओर, break; foreach कथन पूरी तरह से छोड़ देगा और शेष पंक्तियों को कभी संसाधित नहीं किया जाएगा।
जोड़ा लेखक Jeppe Stig Nielsen, स्रोत
नीचे पोस्ट की समाप्ति के साथ ब्लॉग पोस्ट adamthings.com/post/2012/07/26/…
जोड़ा लेखक Adam, स्रोत

14 उत्तर

break will exit the loop completely, continue will just skip the current iteration.

उदाहरण के लिए:

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

    DoSomeThingWith(i);
}

ब्रेक से पहले पुनरावृत्ति पर लूप को बाहर निकलने का कारण बन जाएगा - DoSomeThingWith कभी निष्पादित नहीं किया जाएगा। यह इधर:

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

    DoSomeThingWith(i);
}

i = 0 के लिए doSomeThingWith निष्पादित नहीं करेगा, लेकिन लूप जारी रहेगा और DoSomeThingWith को i = 1 से i = 9

0
जोड़ा
@ जॉर्ज विल्लकोक्स मेरी छोटी, अधिक मूर्खतापूर्ण आत्म ने अभी तक ब्रेसिज़ का उपयोग करने के मूल्य को अभी तक नहीं सीखा है। (वे एकल कथन के लिए सी # में वैकल्पिक हैं, लेकिन उन्हें डालने से बाद में एक बग पेश करना आसान हो जाता है। प्रोग्रामर भी देखें। stackexchange.com/a/16530/6342 )
जोड़ा लेखक Michael Stum, स्रोत
उनके चारों ओर कोई ब्रेसिज़ क्यों जारी नहीं है - मुझे पता है कि यह उनके बिना काम करता है, लेकिन क्यों?
जोड़ा लेखक George Willcox, स्रोत

रूबी दुर्भाग्य से थोड़ा अलग है। पीएस: अगर मैं गलत हूं तो मेरी याददाश्त इस माफी पर थोड़ी आलसी है

ब्रेक / जारी रखने के बजाय, इसमें ब्रेक / अगला है, जो लूप के मामले में समान व्यवहार करता है

लूप्स (बाकी सब कुछ की तरह) अभिव्यक्तियां हैं, और उन्होंने आखिरी चीज "वापसी" की है। अधिकांश समय, लूप से रिटर्न वैल्यू प्राप्त करना व्यर्थ है, इसलिए हर कोई बस ऐसा करता है

a = 5
while a < 10
    a + 1
end

हालांकि आप यह कर सकते हैं

a = 5
b = while a < 10
    a + 1
end # b is now 10

हालांकि, एक ब्लॉक का उपयोग करके बहुत सारे रूबी कोड 'लूप' emulates। कैननिकल उदाहरण है

10.times do |x|
    puts x
end

चूंकि लोग ब्लॉक के परिणामस्वरूप चीजों को करना चाहते हैं, यह वही है जहां यह गन्दा हो जाता है। ब्लॉक के संदर्भ में ब्रेक / अगली मतलब अलग-अलग चीजें।

ब्लॉक को कॉल करने वाले कोड से बाहर निकल जाएगा

अगला ब्लॉक में शेष कोड को छोड़ देगा, और ब्लॉक के कॉलर को जो भी निर्दिष्ट करेगा उसे 'वापसी' करें। यह उदाहरण के बिना कोई समझ नहीं आता है।

def timesten
    10.times{ |t| puts yield t }
end


timesten do |x|
   x * 2
end
# will print
2
4
6
8 ... and so on


timesten do |x|
    break
    x * 2
end
# won't print anything. The break jumps out of the timesten function entirely, and the call to `puts` inside it gets skipped

timesten do |x|
    break 5
    x * 2
end
# This is the same as above. it's "returning" 5, but nobody is catching it. If you did a = timesten... then a would get assigned to 5

timesten do |x|
    next 5
    x * 2
end 
# this would print
5
5
5 ... and so on, because 'next 5' skips the 'x * 2' and 'returns' 5.

तो हाँ। रुबी बहुत बढ़िया है, लेकिन इसमें कुछ भयानक कोने-मामले हैं। यह मेरे द्वारा उपयोग किए जाने वाले वर्षों में मैंने देखा दूसरा दूसरा सबसे बुरा है :-)

0
जोड़ा

ऐसे कुछ लोग हैं जो break और जारी रखें पसंद नहीं करते हैं। डगलस क्रॉकफ़ोर्ड द्वारा मैंने देखी गई नवीनतम शिकायत जावास्क्रिप्ट: गुड पार्ट्स में थी। लेकिन मुझे लगता है कि कभी-कभी उनमें से एक का उपयोग चीजों को सरल बनाता है, खासकर यदि आपकी भाषा में do-while या do-till लूप की शैली शामिल नहीं है।

मैं लूप में break का उपयोग करता हूं जो किसी चीज़ की सूची खोज रहे हैं। एक बार पाया, जारी रखने में कोई बात नहीं है, तो आप भी छोड़ सकते हैं।

मैं किसी सूची के अधिकांश तत्वों के साथ कुछ करते समय जारी रखें का उपयोग करता हूं, लेकिन फिर भी कुछ को छोड़ना चाहता हूं।

किसी को या किसी चीज़ से वैध प्रतिक्रिया के लिए मतदान करते समय break कथन भी आसान होता है। के बजाय:

Ask a question
While the answer is invalid:
    Ask the question

आप कुछ डुप्लिकेशंस को खत्म कर सकते हैं और उपयोग कर सकते हैं:

While True:
    Ask a question
    If the answer is valid:
        break

do-till लूप जिसे मैंने पहले उल्लेख किया है वह उस विशेष समस्या के लिए अधिक सुरुचिपूर्ण समाधान है:

Do:
    Ask a question
    Until the answer is valid

कोई डुप्लिकेशन नहीं, और कोई भी break की आवश्यकता नहीं है।

0
जोड़ा

break would stop the foreach loop completely, continue would skip to the next DataRow.

0
जोड़ा

उदाहरण द्वारा

foreach(var i in Enumerable.Range(1,3))
{
    Console.WriteLine(i);
}

प्रिंट 1, 2, 3 (अलग लाइनों पर)।

I = 2 पर ब्रेक स्थिति जोड़ें

foreach(var i in Enumerable.Range(1,3))
{
    if (i == 2)
        break;

    Console.WriteLine(i);
}

अब लूप 1 प्रिंट करता है और बंद हो जाता है।

ब्रेक को जारी रखने के साथ बदलें।

foreach(var i in Enumerable.Range(1,3))
{
    if (i == 2)
        continue;

    Console.WriteLine(i);
}

अब लूप प्रिंट 1 और 3 (2 छोड़ना)।

इस प्रकार, break लूप को रोकता है, जबकि जारी रखें अगले पुनरावृत्ति पर छोड़ देता है।

0
जोड़ा

मैं हमेशा भ्रमित हो जाता था कि मुझे ब्रेक का उपयोग करना चाहिए या जारी रखना चाहिए। यह मुझे याद रखने में मदद करता है:

ब्रेक बनाम जारी रखने के लिए कब जारी रखें?

  1. Break - it's like breaking up. It's sad, you guys are parting.

ब्रेक

  1. Continue - means that you're gonna give today a rest and sort it all out tomorrow (i.e. skip the current iteration)!

जारी रखें

0
जोड़ा

फोरैच लूप से पूरी तरह से तोड़ने के लिए, break का उपयोग किया जाता है;

लूप में अगले पुनरावृत्ति पर जाने के लिए, जारी रखें का उपयोग किया जाता है;

Break is useful if you?re looping through a collection of Objects (like Rows in a Datatable) and you are searching for a particular match, when you find that match, there?s no need to continue through the remaining rows, so you want to break out.

Continue is useful when you have accomplished what you need to in side a loop iteration. You?ll normally have continue after an if.

0
जोड़ा

इसे समझने का एक आसान तरीका यह है कि प्रत्येक कीवर्ड के बाद "लूप" शब्द डालना है। शब्द अब समझ में आता है अगर वे सिर्फ रोज़ाना वाक्यांशों की तरह पढ़ते हैं।

break loop - looping is broken and stops.

continue loop - loop continues to execute with the next iteration.

0
जोड़ा

break causes the program counter to jump out of the scope of the innermost loop

for(i = 0; i < 10; i++)
{
    if(i == 2)
        break;
}

इस तरह काम करता है

for(i = 0; i < 10; i++)
{
    if(i == 2)
        goto BREAK;
}
BREAK:;

continue jumps to the end of the loop. In a for loop, continue jumps to the increment expression.

for(i = 0; i < 10; i++)
{
    if(i == 2)
        continue;

    printf("%d", i);
}

इस तरह काम करता है

for(i = 0; i < 10; i++)
{
    if(i == 2)
        goto CONTINUE;

    printf("%d", i);

    CONTINUE:;
}
0
जोड़ा
@DanielPark दोनों जबकि ("प्री-टेस्ट") और do - जबकि ("पोस्ट-परीक्षण") के लिए, जारी रखें; कथन अगली चीज़ से मुलाकात की जाएगी जो यह होगा कि लूप स्थिति का मूल्यांकन यह तय करने के लिए किया जाता है कि अतिरिक्त पुनरावृत्ति करना है या नहीं। बेशक, break; लूप स्थिति नहीं चेक की गई है, लूप पूरी तरह से बाहर निकल गया है। तो इस पहलू को समझने के लिए goto समानता भी अच्छी है।
जोड़ा लेखक Jeppe Stig Nielsen, स्रोत
मैंने देखा है कि यहां कई लूप मानक के लिए लूप का उपयोग करते हैं, लेकिन क्या यह पूर्व और पोस्ट परीक्षण जबकि loops के लिए काम करेगा? goto नोटेशन मुझे विश्वास करने के लिए प्रेरित करता है, लेकिन कुछ सत्यापन की आवश्यकता है।
जोड़ा लेखक Daniel Park, स्रोत
@Daniel, WHILE loops के लिए आप BREAK का उपयोग कर सकते हैं और जारी रखें, कोई समस्या नहीं है।
जोड़ा लेखक Amila, स्रोत

सरल उत्तर:

Break exits the loop immediately.
Continue starts processing the next item. (If there are any, by jumping to the evaluating line of the for/while)

0
जोड़ा

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

// break statement
for (int i = 0; i < 5; i++) {
    if (i == 3) {
        break; // It will force to come out from the loop
    }

    lblDisplay.Text = lblDisplay.Text + i + "[Printed] ";
}

आउटपुट यहां है:

0 [मुद्रित] 1 [मुद्रित] 2 [मुद्रित]

So 3[Printed] & 4[Printed] will not be displayed as there is break when i == 3

//continue statement
for (int i = 0; i < 5; i++) {
    if (i == 3) {
        continue; // It will take the control to start point of loop
    }

    lblDisplay.Text = lblDisplay.Text + i + "[Printed] ";
}

आउटपुट यहां है:

0 [मुद्रित] 1 [मुद्रित] 2 [मुद्रित] 4 [मुद्रित]

तो 3 [मुद्रित] प्रदर्शित नहीं किया जाएगा क्योंकि i == 3 जारी है

0
जोड़ा

तोड़

तत्काल बाहर निकलने के लिए एक लूप को तोड़ दें।

जारी रखें

यह ब्रेक के विपरीत करता है। लूप को समाप्त करने के बजाय, यह शेष कोड को छोड़कर तुरंत लूप करता है।

0
जोड़ा
जारी रखें लूप की स्थिति भी जांचें :)
जोड़ा लेखक Grantly, स्रोत
जारी रखें break के विपरीत नहीं है, break लूप को रोकता है, जारी रखें वर्तमान पुनरावृत्ति को रोकता है।
जोड़ा लेखक Steven, स्रोत

यदि आप break का उपयोग नहीं करना चाहते हैं तो आप केवल इस तरह के मान को बढ़ाएं कि यह पुनरावृत्ति की स्थिति को गलत बनाता है और लूप अगले पुनरावृत्ति पर निष्पादित नहीं होगा।

for(int i = 0; i < list.Count; i++){
   if(i == 5)
    i = list.Count;  //it will make "i
0
जोड़ा

अन्य भाषाओं के लिए:

'VB
For i=0 To 10
   If i=5 then Exit For '= break in C#;
   'Do Something for i<5
next

For i=0 To 10
   If i=5 then Continue For '= continue in C#
   'Do Something for i<>5...
Next
0
जोड़ा