ప్రధాన కంటెంట్‌కు వెళ్లండి
మాడ్యూల్ 2 · 2లో పాఠం 1కోర్సులో 3/14~12 min
మాడ్యూల్ పాఠాలు (1/2)

షరతులు మరియు లూప్‌లు

రస్ట్‌లోని నియంత్రణ ప్రవాహం రెండు ప్రధాన నిర్మాణాల చుట్టూ తిరుగుతుంది: ఏ ఎగ్జిక్యూషన్ పాత్‌ను తీసుకోవాలో నిర్ణయించడానికి షరతులతో కూడిన వ్యక్తీకరణలు మరియు సూచనలను పునరావృతం చేయడానికి లూప్ నిర్మాణాలు.

షరతులు: if వ్యక్తీకరణగా

రస్ట్‌లో, if స్టేట్‌మెంట్ ఎక్స్‌ప్రెషన్, అంటే ఇది విలువను అందిస్తుంది. వేరియబుల్‌కు విలువను నేరుగా కేటాయించడానికి మేము ifని ఉపయోగించవచ్చు:

Rust
let condition = true;
let number = if condition { 5 } else { 6 }; // if/else as an expression

లూప్‌లు మరియు పునరావృత్తులు

రస్ట్ మూడు రకాల స్థానిక లూప్‌లను అందిస్తుంది: loop, while, మరియు for.

1. loop (అనంతమైన లూప్)

loop కీవర్డ్ అనంతమైన లూప్‌ను సృష్టిస్తుంది, అది breakని ఉపయోగించడం ఆపివేయమని మీరు స్పష్టంగా చెప్పే వరకు కొనసాగుతుంది:

Rust
let mut count = 0;
loop {
    count += 1;
    if count == 10 {
        break; // Exit the loop
    }
}

అదనంగా, మీరు break తర్వాత దాన్ని ఉంచడం ద్వారా loop నుండి విలువను తిరిగి ఇవ్వవచ్చు:

Rust
let result = loop {
    count += 1;
    if count == 10 {
        break count * 2; // Returns 20
    }
};

2. while (షరతులతో కూడిన లూప్)

బూలియన్ షరతు నిజం అయినంత వరకు కోడ్ బ్లాక్‌ని అమలు చేస్తుంది:

Rust
let mut number = 3;
while number != 0 {
    println!("{}!", number);
    number -= 1;
}

3. for (సేకరణలు మరియు పరిధులపై పునరావృతం)

for లూప్ అనేది సేకరణ లేదా సంఖ్యల పరిధిలోని మూలకాలపై పునరావృతం చేయడానికి అత్యంత సాధారణ మరియు సురక్షితమైన సాధనం:

Rust
// Iterates over numbers 1 through 3 (excluding 4)
for number in 1..4 {
    println!("Valore: {}", number);
}

// Iterates including the right boundary using '='
for number in 1..=3 {
    println!("Valore: {}", number); // Prints 1, 2 and 3
}

లూప్ లేబుల్స్

సమూహ లూప్‌లతో వ్యవహరించేటప్పుడు, break మరియు continue స్టేట్‌మెంట్‌లు డిఫాల్ట్‌గా లోపలి లూప్‌కి వర్తిస్తాయి. ఔటర్ లూప్‌ను స్పష్టంగా ముగించడానికి లేదా కొనసాగించడానికి లూప్ లేబుల్ ('label_name: అని వ్రాయబడింది) ఉపయోగించడానికి రస్ట్ మిమ్మల్ని అనుమతిస్తుంది:

Rust
let mut count = 0;
'outer: loop {
    loop {
        if count == 5 {
            break 'outer; // Exits the outer loop directly
        }
        count += 1;
    }
}

మీరే ప్రయత్నించండి

వ్యాయామం#rust.m2.l1.e1
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

7 విలువతో ఒక వేరియబుల్ పేరుతో ఉన్న సంఖ్యను ప్రకటించండి. తర్వాత, సంఖ్య 5 కంటే ఎక్కువ ఉంటే వేరియబుల్ సందేశానికి 'గ్రేటర్' లేదా లేకపోతే 'చిన్నది' విలువను కేటాయించడానికి if/else వ్యక్తీకరణను ఉపయోగించండి. చివరగా, println ఉపయోగించి సందేశాన్ని ముద్రించండి!.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

`లెట్ మెసేజ్ = నంబర్ > 5 {'గ్రేటర్' } అయితే {'చిన్నది'};` అని వ్రాసి, దానిని `ప్రింట్ల్న్!`కి పాస్ చేయండి.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

వ్యాయామం#rust.m2.l1.e2
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

printlnని ఉపయోగించి 1 నుండి 5 వరకు (అంటే 1, 2, 3, 4, 5) సంఖ్యలను ముద్రించే లూప్ కోసం వ్రాయండి! ప్రతి పునరావృతం వద్ద.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

1

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

వ్యాయామం#rust.m2.l1.e3
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

0 నుండి ప్రారంభమయ్యే మ్యూటబుల్ వేరియబుల్ కౌంటర్‌ను పెంచే లూప్‌ను వ్రాయండి. కౌంటర్ 10కి చేరుకున్నప్పుడు, ఈ విలువను మార్పులేని వేరియబుల్ ఫలితానికి కేటాయించడానికి బ్రేక్ స్టేట్‌మెంట్‌ని ఉపయోగించి 5తో గుణించిన లూప్ రిటర్నింగ్ కౌంటర్ నుండి నిష్క్రమించండి. చివరగా, ప్రింట్ ఫలితం.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

`లెట్ ఫలితం = లూప్ { ... };` ఉపయోగించండి. లూప్ ఇంక్రిమెంట్ లోపల `కౌంటర్` మరియు షరతు `if కౌంటర్ == 10 {బ్రేక్ కౌంటర్ * 5; }`.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది