Rust
लूप्स

वाक्य - विन्यास

• लूप { ब्लॉक } // अनंत लूप

• जबकि हालत { ब्लॉक }

• जबकि प्रतिमान = expr { block } रहने दें

• expr { block } // expr में पैटर्न के लिए IntoIterator को लागू करना चाहिए

• जारी रखें // लूप बॉडी के अंत में कूदें, यदि आवश्यक हो तो एक नया चलना शुरू करें

• ब्रेक // लूप बंद करो

• ' लेबल : लूप { ब्लॉक }

• ' लेबल : जबकि स्थिति { ब्लॉक }

• ' लेबल : जबकि पैटर्न = एक्सप्रा { ब्लॉक } दें

• ' लेबल : expr { ब्लॉक } में पैटर्न के लिए

• यदि आवश्यक हो तो एक नया पुनरावृत्ति शुरू, लूप बॉडी लेबल लेबल के अंत में ' लेबल // कूद' जारी रखें

• ब्रेक ' लेबल // लूप लेबल लेबल बंद करो

मूल बातें

रस्ट में 4 लूपिंग कंस्ट्रक्शन हैं। नीचे दिए गए सभी उदाहरण एक ही आउटपुट का उत्पादन करते हैं।

अनंत लूप्स

let mut x = 0;
loop {
    if x > 3 { break; }
    println!("{}", x);
    x += 1;
}

जबकि लूप्स

let mut x = 0;
while x <= 3 {
    println!("{}", x);
    x += 1;
}

यह भी देखें: loop और while true क्या अंतर while true ?

पैटर्न-मैचेड जबकि लूप्स

ये कभी कभी के रूप में जाना जाता है while let संक्षिप्तता के लिए लूप।

let mut x = Some(0);
while let Some(v) = x {
    println!("{}", v);
    x = if v < 3 { Some(v + 1) }
        else     { None };
}

यह loop ब्लॉक के अंदर एक match बराबर है:

let mut x = Some(0);
loop {
    match x {
        Some(v) => {
            println!("{}", v);
            x = if v < 3 { Some(v + 1) }
                else     { None };
        }
        _       => break,
    }
}

लूप्स के लिए

जंग में, लूप के for केवल एक "चलने योग्य" ऑब्जेक्ट के साथ इस्तेमाल किया जा सकता है (यानी इसे IntoIterator लागू करना चाहिए)।

for x in 0..4 {
    println!("{}", x);
}

यह निम्नलिखित स्निपेट के समतुल्य है, while let :

let mut iter = (0..4).into_iter();
while let Some(v) = iter.next() {
    println!("{}", v);
}

नोट: 0..4 एक Range ऑब्जेक्ट देता है जो पहले से ही Iterator विशेषता को लागू करता है। इसलिए into_iter() अनावश्यक है, लेकिन इसके लिए क्या करना है for यह स्पष्ट करने के लिए रखा गया है। बारे में गहराई से देखने के लिए, पर आधिकारिक दस्तावेज़ देख सकेंगे for लूप्स और IntoIterator ।

इसे भी देखें: Iterators

लूप्स के बारे में अधिक जानकारी

जैसा कि मूल बातें में उल्लेख किया गया है, हम कुछ भी इस्तेमाल कर सकते हैं जो लूप के for IntoIterator को लागू IntoIterator :

let vector = vec!["foo", "bar", "baz"]; // vectors implement IntoIterator
for val in vector {
    println!("{}", val);
}

अपेक्षित उत्पादन:

foo  
bar  
baz

ध्यान दें कि इस तरह vector पर पुनरावृत्ति होती है, इसका उपभोग करते हैं (लूप के for , vector फिर से उपयोग नहीं किया जा सकता है)। इसका कारण यह है कि IntoIterator::into_iter self चलता है ।

IntoIterator भी द्वारा कार्यान्वित किया जाता &Vec<T> और &mut Vec<T> (प्रकार के साथ मूल्यों उपज &T और &mut T ताकि आप के इस कदम को रोका जा सकता क्रमशः) vector बस संदर्भ द्वारा यह पारित करके:

let vector = vec!["foo", "bar", "baz"];
for val in &vector {
    println!("{}", val);
}
println!("{:?}", vector);

ध्यान दें कि val टाइप &&str , क्योंकि vector Vec<&str> ।

लूप नियंत्रण

सभी लूपिंग निर्माण, break के उपयोग और बयान continue की अनुमति देते हैं। वे तुरंत आसपास के (अंतरतम) लूप को प्रभावित करते हैं।

बेसिक लूप कंट्रोल

break लूप को समाप्त करता है:

for x in 0..5 {
    if x > 2 { break; }
    println!("{}", x);
}

0
1
2

continue वर्तमान पुनरावृत्ति को जल्दी पूरा करता है

for x in 0..5 {
    if x < 2 { continue; }
    println!("{}", x);
}

2
3
4

उन्नत लूप नियंत्रण

अब, मान लीजिए कि हमारे पास नेस्टेड लूप हैं और बाहरी लूप को break चाहते हैं। फिर, हम लूप लेबल्स का उपयोग यह निर्दिष्ट करने के लिए कर सकते हैं कि कौन सा लूप break या continue है। निम्नलिखित उदाहरण में, 'outer बाहरी लूप को दिया गया लेबल है।

'outer: for i in 0..4 {
    for j in i..i+2 {
        println!("{} {}", i, j);
        if i > 1 {
            continue 'outer;
        }
    }
    println!("--");
}

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

i > 1 , आंतरिक लूप केवल एक बार पुनरावृत्त हुआ और -- मुद्रित नहीं किया गया।

नोट: एक लूप लेबल को जीवन भर चर के साथ भ्रमित न करें। लाइफटाइम चर केवल एक बगल में होता है & या भीतर एक सामान्य पैरामीटर के रूप में <>