2009-03-17 9 views
247

पर्ल में मैं next; कमांड के साथ एक foreach (या किसी भी लूप) पुनरावृत्ति छोड़ सकता है।मैं 'foreach` लूप का पुनरावृत्ति कैसे छोड़ूं?

क्या पुनरावृत्ति को छोड़ने और सी # में अगले लूप पर जाने का कोई तरीका है?

foreach (int number in numbers) 
{ 
    if (number < 0) 
    { 
     // What goes here to skip over the loop? 
    } 

    // otherwise process number 
} 
+0

उपयोगकर्ता को उनके खराब इनपुट के साथ सूचित करना उतना ही महत्वपूर्ण है जितना इसे छोड़ना! – usefulBee

उत्तर

514

आप चाहते हैं:

foreach (int number in numbers) // <--- go back to here --------+ 
{        //        | 
    if (number < 0)    //        | 
    {       //        | 
     continue; // Skip the remainder of this iteration. -----+ 
    } 

    // do work 
} 

यहाँ continue keyword के बारे में अधिक है।


अद्यतन: टिप्पणी में ब्रायन की अनुवर्ती प्रश्न के उत्तर में:

आप आगे स्पष्ट किया जा सका अगर मैं छोरों के लिए नेस्ट था मैं क्या कर सकता है, और यात्रा छोड़ करना चाहता था विस्तारित लोगों में से एक का?

for (int[] numbers in numberarrays) { 
    for (int number in numbers) { // What to do if I want to 
           // jump the (numbers/numberarrays)? 
    } 
} 

एक continue हमेशा निकटतम enclosing दायरे पर लागू होता है, तो आप इसका इस्तेमाल नहीं कर सकता है सबसे बाहरी लूप से बाहर तोड़ने के लिए। यदि ऐसी स्थिति उत्पन्न होती है, तो आपको आंतरिक लूप से break जैसे बाहरी लूप पर continue जैसे सटीक के आधार पर कुछ और जटिल करना होगा। break keyword पर प्रलेखन के लिए यहां देखें। break सी # कीवर्ड पर्ल last कीवर्ड के समान है।

इसके अलावा, डस्टिन के सुझाव लेने के सिर्फ मूल्यों को फिल्टर करने पर विचार आप पहले से संसाधित करने के लिए नहीं करना चाहती:

foreach (var basket in baskets.Where(b => b.IsOpen())) { 
    foreach (var fruit in basket.Where(f => f.IsTasty())) { 
    cuteAnimal.Eat(fruit); // Om nom nom. You don't need to break/continue 
          // since all the fruits that reach this point are 
          // in available baskets and tasty. 
    } 
} 
+0

क्या आप आगे स्पष्टीकरण दे सकते हैं कि अगर मैं लूप के लिए घोंसला करता था तो मैं क्या करूँगा, और विस्तारित लोगों में से एक के पुनरावृत्ति को छोड़ना चाहता था? पूर्व: (int [] numberarrays में संख्या) के लिए { (संख्या में पूर्णांक संख्या) के लिए { // अगर (संख्या/numberarrays) कूद करने के } करना चाहते हैं क्या} – Brian

+0

सी # के 'goto' वास्तव में स्थिति के लिए उपयोगी है @ ब्रायन के बारे में पूछ रहा है। बाहरी लूप के नीचे 'nextArray:' जैसे लेबल जोड़ें, और उसके बाद 'goto nextArray;' जब आप इसे छोड़ना चाहते हैं। –

17
foreach (int number in numbers) 
{ 
    if (number < 0) 
    { 
     continue; 
    } 

    //otherwise process number 
} 
7

उपयोग बयान जारी रखने के लिए:

foreach(object o in mycollection) { 
    if(number < 0) { 
     continue; 
    } 
    } 
+3

समझ में नहीं आता कि यह क्यों उखाड़ फेंक दिया गया है, यह गलत है क्योंकि वह "ओ" पर लूप करता है, न कि "संख्या" – Fortune

+0

सहमत है, शायद यह पिछले उत्तरों से एक प्रतिलिपि/पेस्ट है? संकल्पनात्मक रूप से मूल्यवान है क्योंकि यह एक foreach है, लेकिन कृपया सुनिश्चित करें कि चर स्थिर हैं। –

12

आप continue कथन का उपयोग कर सकते हैं।

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

foreach(int number in numbers) 
{ 
    if(number < 0) 
    { 
     continue; 
    } 
} 
23

तुम भी फ्लिप सकता है कि आपके अगर परीक्षण:


foreach (int number in numbers) 
{ 
    if (number >= 0) 
    { 
     //process number 
    } 
} 
+0

:) धन्यवाद! मैं एक मूल उदाहरण के साथ आया क्योंकि लूप की शुरुआत में कुछ मानदंड थे जिन्हें संसाधित करने की आवश्यकता नहीं थी, और अन्य जो त्रुटियों को पकड़े जाने की आवश्यकता थी। 'जारी रखें' – Brian

+0

+1 कृपया अधिक ifs का उपयोग न करें :( – Trap

+4

का उपयोग न करने के लिए – Custodio

43

एक और दृष्टिकोण LINQ उपयोग करने से पहले पाश कार्यान्वित फिल्टर करने के लिए है:

foreach (int number in numbers.Where(n => n >= 0)) 
{ 
    // process number 
} 
+2

+1। हालांकि यह नहीं है प्रश्न के लिए सीधी प्रतिक्रिया, व्यावहारिक रूप से मैं शायद इस समाधान को पसंद करता हूं जिसे मैंने प्रस्तावित किया था। LINQ का उपयोग करना उन लूप मानों को फ़िल्टर करने के लिए एक अच्छा सामान्य उपयोग केस जैसा प्रतीत होता है, जिन्हें आप संसाधित नहीं करना चाहते हैं। –

+3

क्या यह सिर्फ मामूली है या क्या यह वास्तव में तेज होगा कि भविष्यवाणी करने के लिए कम है? मुझे लगता है कि LINQ बहुत अनुकूलित है लेकिन LINQ अनुभाग को किसी बिंदु पर पूर्वानुमान करना होगा ताकि सैद्धांतिक रूप से डेटासेट बड़ा हो और परिणामी 'फ़िल्टर किया गया' सबसेट लगभग बड़ा, तो यह धीमा हो जाएगा क्योंकि एक foreach दो बार होना है? तो शायद यह अपेक्षित परिणाम उप-डेटासेट पर निर्भर करता है? – Coops

12

एक और दृष्टिकोण linq का उपयोग कर रहा है:

foreach (int number in numbers.Skip(1)) 
{ 
    // process number 
} 

यदि आप पहले कई वस्तुओं में छोड़ना चाहते हैं।

या यदि आप छोड़ने के लिए कोई शर्त निर्दिष्ट करना चाहते हैं तो .SkipWhere का उपयोग करें।