मैं `फॉरच` लूप के पुनरावृत्ति को कैसे छोड़ूँ?

Question

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

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

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

     // otherwise process number
 }

Comments

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

— उपयोगी

Answer 1

तुम्हें चाहिए:

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

    // do work
}

यहां continueकीवर्ड के बारे में अधिक बताया गया है ।

---

अपडेट: टिप्पणियों में ब्रायन के अनुवर्ती सवाल के जवाब में:

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

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

एक continueहमेशा निकटतम संलग्न गुंजाइश पर लागू होता है, तो आप इसका इस्तेमाल नहीं कर सकता है सबसे बाहरी लूप से बाहर तोड़ने के लिए। यदि इस तरह की स्थिति उत्पन्न होती है, तो आपको breakआंतरिक लूप की तरह continueही बाहरी लूप पर , जैसा आप चाहते हैं, उसके आधार पर कुछ अधिक जटिल करने की आवश्यकता होगी । breakकीवर्ड पर प्रलेखन के लिए यहां देखें । 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.
  }
}

Comments

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

— ब्रायन

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

— याकूब क्राल

Answer 2

लूप निष्पादित होने से पहले LINQ का उपयोग करने के लिए एक और तरीका है:

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

Comments

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

— जॉन फेमिनेला

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

— Coops

Answer 3

यदि आप परीक्षण कर सकते हैं, तो आप अपना फ्लिप भी कर सकते हैं:

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

Comments

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

— ब्रायन

एक LINQ आधारित उत्तर अच्छा है और इसमें एक लालित्य है, लेकिन यदि एक कथन का उपयोग करना गलत नहीं है।

— क्रैश

Answer 4

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

    //otherwise process number
}

Answer 5

आप उपयोग कर सकते हैं continue स्टेटमेंट का ।

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

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

Answer 6

लाइनक का उपयोग करने का एक और तरीका है:

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

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

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

Comments

यह ऐसा करने का सबसे सरल (हालांकि शायद तर्क के अंदर एक ही है) तरीका है - अब जब आपके पास लिनक उपलब्ध है। हालांकि आपको यह सुनिश्चित करना चाहिए कि प्रदर्शन कारणों से केवल एक बार S.Sip को बुलाया जाए। (हाँ, अब मैं देख रहा हूं कि यह ओपी के सवाल का सीधा आगे का जवाब नहीं है, हालांकि जवाब की इस सूची के लिए एक मूल्यवान अतिरिक्त है)। +1

— बी चार्ल्स एच

Answer 7

जारी बयान का उपयोग करें:

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

Comments

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

— फॉर्च्यून

सहमत, शायद यह पिछले उत्तरों से कॉपी / पेस्ट है? अवधारणात्मक रूप से मूल्यवान है क्योंकि यह एक फ़ार्च है, लेकिन कृपया सुनिश्चित करें कि चर सुसंगत हैं।

— एंटोनियो कोलिनो

Answer 8

ऐसा करने का सबसे आसान तरीका नीचे दिया गया है:

//Skip First Iteration

foreach ( int number in numbers.Skip(1))

//Skip any other like 5th iteration

foreach ( int number in numbers.Skip(5))