మాడ్యూల్ పాఠాలు (1/2)
షరతులు మరియు లూప్లు
రస్ట్లోని నియంత్రణ ప్రవాహం రెండు ప్రధాన నిర్మాణాల చుట్టూ తిరుగుతుంది: ఏ ఎగ్జిక్యూషన్ పాత్ను తీసుకోవాలో నిర్ణయించడానికి షరతులతో కూడిన వ్యక్తీకరణలు మరియు సూచనలను పునరావృతం చేయడానికి లూప్ నిర్మాణాలు.
షరతులు: if వ్యక్తీకరణగా
రస్ట్లో, if స్టేట్మెంట్ ఎక్స్ప్రెషన్, అంటే ఇది విలువను అందిస్తుంది. వేరియబుల్కు విలువను నేరుగా కేటాయించడానికి మేము ifని ఉపయోగించవచ్చు:
let condition = true;
let number = if condition { 5 } else { 6 }; // if/else as an expressionలూప్లు మరియు పునరావృత్తులు
రస్ట్ మూడు రకాల స్థానిక లూప్లను అందిస్తుంది: loop, while, మరియు for.
1. loop (అనంతమైన లూప్)
loop కీవర్డ్ అనంతమైన లూప్ను సృష్టిస్తుంది, అది breakని ఉపయోగించడం ఆపివేయమని మీరు స్పష్టంగా చెప్పే వరకు కొనసాగుతుంది:
let mut count = 0;
loop {
count += 1;
if count == 10 {
break; // Exit the loop
}
}అదనంగా, మీరు break తర్వాత దాన్ని ఉంచడం ద్వారా loop నుండి విలువను తిరిగి ఇవ్వవచ్చు:
let result = loop {
count += 1;
if count == 10 {
break count * 2; // Returns 20
}
};2. while (షరతులతో కూడిన లూప్)
బూలియన్ షరతు నిజం అయినంత వరకు కోడ్ బ్లాక్ని అమలు చేస్తుంది:
let mut number = 3;
while number != 0 {
println!("{}!", number);
number -= 1;
}3. for (సేకరణలు మరియు పరిధులపై పునరావృతం)
for లూప్ అనేది సేకరణ లేదా సంఖ్యల పరిధిలోని మూలకాలపై పునరావృతం చేయడానికి అత్యంత సాధారణ మరియు సురక్షితమైన సాధనం:
// 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: అని వ్రాయబడింది) ఉపయోగించడానికి రస్ట్ మిమ్మల్ని అనుమతిస్తుంది:
let mut count = 0;
'outer: loop {
loop {
if count == 5 {
break 'outer; // Exits the outer loop directly
}
count += 1;
}
}మీరే ప్రయత్నించండి
7 విలువతో ఒక వేరియబుల్ పేరుతో ఉన్న సంఖ్యను ప్రకటించండి. తర్వాత, సంఖ్య 5 కంటే ఎక్కువ ఉంటే వేరియబుల్ సందేశానికి 'గ్రేటర్' లేదా లేకపోతే 'చిన్నది' విలువను కేటాయించడానికి if/else వ్యక్తీకరణను ఉపయోగించండి. చివరగా, println ఉపయోగించి సందేశాన్ని ముద్రించండి!.
సూచనను చూపించు
`లెట్ మెసేజ్ = నంబర్ > 5 {'గ్రేటర్' } అయితే {'చిన్నది'};` అని వ్రాసి, దానిని `ప్రింట్ల్న్!`కి పాస్ చేయండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
printlnని ఉపయోగించి 1 నుండి 5 వరకు (అంటే 1, 2, 3, 4, 5) సంఖ్యలను ముద్రించే లూప్ కోసం వ్రాయండి! ప్రతి పునరావృతం వద్ద.
సూచనను చూపించు
1
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
0 నుండి ప్రారంభమయ్యే మ్యూటబుల్ వేరియబుల్ కౌంటర్ను పెంచే లూప్ను వ్రాయండి. కౌంటర్ 10కి చేరుకున్నప్పుడు, ఈ విలువను మార్పులేని వేరియబుల్ ఫలితానికి కేటాయించడానికి బ్రేక్ స్టేట్మెంట్ని ఉపయోగించి 5తో గుణించిన లూప్ రిటర్నింగ్ కౌంటర్ నుండి నిష్క్రమించండి. చివరగా, ప్రింట్ ఫలితం.
సూచనను చూపించు
`లెట్ ఫలితం = లూప్ { ... };` ఉపయోగించండి. లూప్ ఇంక్రిమెంట్ లోపల `కౌంటర్` మరియు షరతు `if కౌంటర్ == 10 {బ్రేక్ కౌంటర్ * 5; }`.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది