Roestbeheersingsstructuren en hoe ze te gebruiken

Besturingsstructuren zijn een programmeerconstructie waarmee u de uitvoeringsstroom in uw programma's kunt regelen. Met besturingsstructuren kunt u instructies specificeren die alleen moeten worden uitgevoerd als aan bepaalde voorwaarden is voldaan.

De besturingsstructuren van Rust zijn cruciaal voor het beheer van de programmastroom, waardoor efficiënte code-uitvoering mogelijk wordt en complexe taken worden vereenvoudigd tot kleinere, herbruikbare componenten.

Roest Voorwaardelijke Verklaringen

Voorwaardelijke instructies zijn constructies waarmee u code kunt uitvoeren op basis van voorwaarden. Voorwaardelijke verklaringen zijn handig bij het nemen van beslissingen, aangezien de uitvoering van het programma afhangt van het feit of de voorwaarde evalueert WAAR of vals. Roest zorgt als, anders, En overeenkomst verklaringen voor besluitvorming.

In Rust-programma's is de als statement test of een bepaalde voorwaarde waar is. Als dit het geval is, voert het programma het bijbehorende codeblok uit. Als de voorwaarde false evalueert, slaat het programma dat codeblok over en gaat verder met de volgende instructie of voert het

anders instructieblok als die er is.

De overeenkomst statement is een krachtige control flow-constructie waarmee een programma waarden kan vergelijken met een reeks patronen en code kan uitvoeren op basis van het overeenkomende patroon.

Rust's if-verklaringen

Je gaat declareren als verklaringen in uw Rust-programma's met de als trefwoord gevolgd door een voorwaarde:

als voorwaarde {
// code om uit te voeren als de voorwaarde waar is
}

Hier is een voorbeeld van hoe u een if-statement kunt gebruiken in uw Rust-programma's:

fnvoornaamst() {
laten x= 15;
als x > 10 {
println!("x is groter dan 10");
 }
}

De X variabele bevat een 32-bits geheel getal en de instructie if controleert of de waarde van x groter is dan tien voordat het codeblok wordt uitgevoerd dat het afdrukt.

Rust's else-verklaringen

Je gebruikt de anders trefwoord om een ​​codeblok uit te voeren wanneer u verwacht dat een als verklaring als onwaar zou evalueren.

als voorwaarde {
// code om uit te voeren als de voorwaarde waar is
} anders {
// code om uit te voeren als de voorwaarde onwaar is
}

Hier is een voorbeeld waar X niet groter is dan 10, de als verklaring evalueert vals, en een anders verklaring loopt.

fnvoornaamst(){
laten x= 5;
als x > 10 {
println!("x is groter dan 10");
 } anders {
println!("x is niet groter dan 10");
 }
}

Sinds X 5 is en 5 niet groter is dan 10, slaat het programma de als blok en voert de anders blok.

Rust's wedstrijdverklaringen

Je gebruikt de overeenkomst trefwoord voor complexe besluitvorming om een ​​reeks patronen te controleren en code uit te voeren op basis van patroonovereenkomsten. Wedstrijdverklaringen zijn vergelijkbaar met switch-instructies in C#, Go en C++.

Dit is de structuur van een Rust-overeenkomstverklaring:

overeenkomst waarde {
 patroon1 => {
// code die moet worden uitgevoerd als de waarde overeenkomt met patroon1
 },
 patroon2 => {
// code die moet worden uitgevoerd als de waarde overeenkomt met patroon2
 },
// enz.
}

Zo kunt u matchstatements in uw programma's gebruiken:

laten cijfer = 'B';
overeenkomst cijfer {
'A' => println!("Goed werk!"),
'B' => println!("Goed gedaan."),
'C' => println!("Je zou het beter kunnen doen."),
 _ => println!("Dat is geen geldig cijfer."),
}

De cijfer variabele is een karakter, en de overeenkomst instructie controleert welke van de karakters resulteert in de waarde van de cijfervariabele voordat de code wordt uitgevoerd na de => operator. U kunt het onderstrepingstekenpatroon (_) gebruiken om overeen te komen met waarden die niet overeenkomen met andere patronen (het standaardpatroon).

Lussen in Roest

Lussen zijn een fundamentele constructie die wordt gebruikt voor repetitieve taken zoals web schrapen en andere geautomatiseerde acties. Rust biedt verschillende soorten lussen, waaronder terwijl lussen, voor lussen, en de lus lus.

Rust's while Loops

While-lussen herhalen een codeblok zolang een opgegeven voorwaarde waar is. Voordat je de voorwaarde opgeeft, specificeer je while-lussen in Rust met de terwijl trefwoord.

terwijl voorwaarde {
// code om uit te voeren
}

De voorwaarde moet een booleaanse uitdrukking zijn die de voortzetting van de lus bepaalt. Wanneer de voorwaarde false evalueert, wordt de lus afgesloten.

Hier is een voorbeeld van een Rust while-lus die getallen van één tot vijf afdrukt.

fnvoornaamst() {
latenmuts ik = 1;
terwijl ik <= 5 {
println!("{}", i);
 ik += 1;
 }
}

De while-lus in de voornaamst functie doorloopt de nummers één tot en met vijf terwijl de i variabel met één totdat i variabele groter is dan vijf, waar de lus eindigt.

De lus Lus

De lus sleutelwoord creëert een oneindige lus totdat u een exit aangeeft met de pauze trefwoord.

lus {
// code om uit te voeren
als voorwaarde {
pauze;
 }
}

De code in de lus block blijft uitvoeren totdat de lus a tegenkomt pauze trefwoord.

Hier is een voorbeeld van het gebruik van de lus lus om nummers één tot en met vijf af te drukken voordat u de pauze trefwoord voor de uitgang.

fnvoornaamst() {
latenmuts ik = 1;
lus {
println!("{}", i);
 ik += 1;
als ik > 5 {
pauze;
 }
 }
}

De voornaamst functie voert de lus uit, en de als verklaring verhoogt de i variabel. De als instructie specificeert de lusbeëindiging wanneer de i variabele groter is dan vijf.

Rust is voor lussen

In Rust doorlopen for-lussen een bereik of een verzameling waarden. Je gebruikt de voor trefwoord om een ​​for-lus te starten, voordat u het bereik of de verzameling specificeert waarop het werkt.

voor variabel in bereik {
// code om uit te voeren
}

De bereik is een uitdrukking die resulteert in een reeks waarden, en de variabele is een variabele die op zijn beurt elke waarde in de reeks aanneemt. Het codeblok wordt één keer uitgevoerd voor elke waarde in de reeks.

Hier is een voorbeeld van een for-lus die waarden van één tot tien afdrukt.

fnvoornaamst() {
voor i in1..=10 {
println!("{}", i);
 }
}

De lus herhaalt de waarden van 1 tot 10. Bij elke iteratie bevat de variabele (i) de volgende waarde, die de println! macro wordt vervolgens afgedrukt.

U kunt de doorgaan trefwoord om waarden in for-loops over te slaan. Zo kunt u de even getallen overslaan wanneer u op een bereik werkt:

fnvoornaamst() {
voor aantal in1..=10 {
als aantal % 2 == 0 {
doorgaan; // sla even getallen over
 }
println!("{}", getal); // druk oneven getallen af
 }
}

De als verklaring gebruikt de doorgaan trefwoord om aan te geven dat de lus getallen moet overslaan die deelbaar zijn door twee.

Bovendien kunt u een for-lus afsluiten met de pauze trefwoord. De lus eindigt bij het tegenkomen van de pauze trefwoord.

fnvoornaamst() {
voor aantal in1..=10 {
als getal == 5 {
pauze; // verlaat de lus wanneer het getal gelijk is aan 5
 }
println!("{}", getal); // druk nummers 1 tot 4 af
 }
}

De als instructie specificeert dat de lus moet eindigen wanneer de i variabele is gelijk aan vijf.

Gebruik de besturingsstructuren van Rust met gegevenstypen om de taal onder de knie te krijgen

Rust biedt deze flexibele besturingsstructuren voor bewerkingen op ingebouwde en aangepaste gegevenstypen. U kunt deze besturingsstructuren gebruiken om te werken op samengestelde en samengestelde gegevensstructuren zoals arrays, vectoren, structuren en opsommingen.

Roest geeft ook structs. Structuren zijn gegevensstructuren die gerelateerde waarden groeperen in een enkel object. Ze lijken op klassen in objectgeoriënteerde talen, en je kunt er zelfs methoden voor definiëren.