முக்கிய உள்ளடக்கத்திற்குச் செல்லவும்
தொகுதி 2 · பாடம் 1 இன் 2பாடத்திட்டத்தில் 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 { 'பெரியது' } வேறு { 'சிறியது' };` என்று எழுதி, அதை `println!` க்கு அனுப்பவும்.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

உடற்பயிற்சி#rust.m2.l1.e2
முயற்சிகள்: 0ஏற்றுகிறது…

println ஐப் பயன்படுத்தி 1 முதல் 5 வரையிலான எண்களை (அதாவது 1, 2, 3, 4, 5) அச்சிடும் for loop ஐ எழுதவும்! ஒவ்வொரு மறு செய்கையிலும்.

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

1

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்

உடற்பயிற்சி#rust.m2.l1.e3
முயற்சிகள்: 0ஏற்றுகிறது…

0 இலிருந்து தொடங்கும் மாறக்கூடிய மாறி கவுண்டரை அதிகரிக்கும் ஒரு லூப்பை எழுதவும். கவுண்டர் 10 ஐ அடையும் போது, ​​இந்த மதிப்பை மாறாத மாறி முடிவிற்கு ஒதுக்க, இடைவெளி அறிக்கையைப் பயன்படுத்தி 5 ஆல் பெருக்கப்படும் லூப் ரிட்டர்னிங் கவுண்டரில் இருந்து வெளியேறவும். இறுதியாக, முடிவை அச்சிடவும்.

எடிட்டரை ஏற்றுகிறது…
குறிப்பைக் காட்டு

`லெட் ரிசல்ட் = லூப் { ... };` ஐப் பயன்படுத்தவும். லூப் இன்க்ரிமென்ட் `கவுண்டர்` உள்ளே மற்றும் நிபந்தனை `if counter == 10 {பிரேக் கவுண்டர் * 5; }`.

3 முயற்சிகளுக்குப் பிறகு தீர்வு கிடைக்கும்