Rustkontrolstrukturer og hvordan man bruger dem

Kontrolstrukturer er en programmeringskonstruktion, der giver dig mulighed for at kontrollere udførelsesflowet i dine programmer. Kontrolstrukturer giver dig mulighed for at angive instruktioner til kun at køre, hvis visse betingelser er opfyldt.

Rusts kontrolstrukturer er afgørende for styring af programflow, hvilket muliggør effektiv kodeudførelse, mens komplekse opgaver forenkles til mindre, genanvendelige komponenter.

Rustbetingelser

Betingede sætninger er konstruktioner, der giver dig mulighed for at køre kode baseret på betingelser. Betingede erklæringer er nyttige til beslutningstagning, da programmets udførelse afhænger af, om tilstanden vurderes til at rigtigt eller falsk. Rust giver hvis, andet, og match erklæringer til beslutningstagning.

I Rust-programmer er hvis udsagn tester, om en bestemt tilstand vurderes til at være sand. Hvis det gør det, kører programmet den tilhørende kodeblok. Hvis betingelsen evalueres falsk, springer programmet over den kodeblok og går videre til den næste sætning eller kører

andet erklæringsblok, hvis der er nogen.

Det match statement er en kraftfuld kontrol-flow-konstruktion, der tillader et program at matche værdier mod en række mønstre og udføre kode baseret på det matchende mønster.

Rust's if-erklæringer

du vil erklære hvis udsagn i dine Rust-programmer med hvis søgeord efterfulgt af en betingelse:

hvis tilstand {
// kode til at udføre, hvis betingelsen er sand
}

Her er et eksempel på, hvordan du kan bruge en if-sætning i dine Rust-programmer:

fnvigtigste() {
lade x = 15;
hvis x > 10 {
println!("x er større end 10");
 }
}

Det x variabel har et 32-bit heltal, og if-sætningen kontrollerer, om værdien af ​​x er større end ti, før den kører kodeblok, der udskriver den.

Rusts andre udtalelser

Du vil bruge andet nøgleord til at udføre en kodeblok, når du forventer, at en hvis udsagn vil blive vurderet som falsk.

hvis tilstand {
// kode til at udføre, hvis betingelsen er sand
} andet {
// kode til at udføre, hvis betingelsen er falsk
}

Her er et eksempel hvor x ikke er større end 10, hvis erklæring vurderer falsk, og en andet erklæring kører.

fnvigtigste(){
lade x = 5;
hvis x > 10 {
println!("x er større end 10");
 } andet {
println!("x er ikke større end 10");
 }
}

Siden x er 5 og 5 ikke er større end 10, springer programmet over hvis blokere og udfører andet blok.

Rusts kamperklæringer

Du vil bruge match nøgleord til kompleks beslutningstagning for at kontrollere en række mønstre og eksekvere kode baseret på mønstermatches. Matchudsagn ligner switch-sætninger i C#, Go og C++.

Her er strukturen af ​​en Rust-match-erklæring:

match værdi {
 mønster1 => {
// kode til at udføre, hvis værdien matcher mønster1
 },
 mønster2 => {
// kode til at udføre, hvis værdien matcher mønster2
 },
// etc.
}

Sådan kan du bruge matchudsagn i dine programmer:

lade karakter = 'B';
match karakter {
'EN' => println!("Fremragende arbejde!"),
'B' => println!("Godt arbejde."),
'C' => println!("Du kunne gøre det bedre."),
 _ => println!("Det er ikke en gyldig karakter."),
}

Det karakter variabel er et tegn, og match sætning kontrollerer, hvilke af tegnene der evalueres til værdien af ​​karaktervariablen, før koden udføres efter =>-operatoren. Du kan bruge understregningsmønsteret (_) til at matche værdier, der ikke matcher andre mønstre (standardmønsteret).

Sløjfer i Rust

Sløjfer er en grundlæggende konstruktion, der bruges til gentagne opgaver som f.eks web skrabning og andre automatiserede handlinger. Rust giver forskellige typer sløjfer, bl.a mens sløjfer, til sløjfer, og sløjfe sløjfe.

Rust's while Loops

Mens loops gentager en kodeblok, så længe en specificeret betingelse evaluerer sand. Før du specificerer betingelsen, skal du angive while-løkker i Rust med mens søgeord.

mens tilstand {
// kode til at udføre
}

Betingelsen skal være et boolesk udtryk, der bestemmer løkkens fortsættelse. Når betingelsen evalueres falsk, afsluttes løkken.

Her er et eksempel på en Rust while-løkke, der udskriver tal fra et til fem.

fnvigtigste() {
lademut i = 1;
mens jeg <= 5 {
println!("{}"i);
 jeg += 1;
 }
}

Mens sløjfen i vigtigste funktionen går gennem tallene et til fem, mens den øger jeg variabel med én indtil jeg variabel er større end fem, hvor løkken ender.

Løkken Loop

Det sløjfe nøgleordet opretter en uendelig løkke, indtil du angiver en exit med pause søgeord.

sløjfe {
// kode til at udføre
hvis tilstand {
pause;
 }
}

Koden i sløjfe blok vil blive ved med at udføre, indtil løkken støder på en pause søgeord.

Her er et eksempel på brug af sløjfe sløjfe for at udskrive nummer et til fem, før du angiver pause nøgleord for udgangen.

fnvigtigste() {
lademut i = 1;
sløjfe {
println!("{}"i);
 jeg += 1;
hvis jeg > 5 {
pause;
 }
 }
}

Det vigtigste funktionen udfører løkken, og hvis erklæring øger jeg variabel. Det hvis statement specificerer sløjfetermineringen, når jeg variabel overstiger fem.

Rust's for Loops

I Rust, for loops iterere gennem et område eller en samling af værdier. Du vil bruge til nøgleord for at starte en for-løkke, før du angiver det interval eller den samling, det virker på.

til variabel i rækkevidde {
// kode til at udføre
}

Det rækkevidde er et udtryk, der evalueres til en sekvens af værdier, og variablen er en variabel, der på skift tager hver værdi i sekvensen. Kodeblokken udføres én gang for hver værdi i sekvensen.

Her er et eksempel på en for-løkke, der udskriver værdier fra én til ti.

fnvigtigste() {
til jeg i1..=10 {
println!("{}"i);
 }
}

Sløjfen itererer gennem værdierne fra 1 til 10. Ved hver iteration holder variablen (i) den næste værdi, som println! makro udskrives derefter.

Du kan bruge Blive ved nøgleord for at springe værdier over i for-loops. Sådan kan du springe de lige tal over, når du arbejder på et område:

fnvigtigste() {
til num i1..=10 {
hvis antal % 2 == 0 {
Blive ved; // spring lige tal over
 }
println!("{}", antal); // udskriv ulige tal
 }
}

Det hvis erklæring bruger Blive ved nøgleord for at angive, at løkken skal springe tal, der er deleligt med to.

Derudover kan du afslutte en for-loop med pause søgeord. Sløjfen afsluttes ved at støde på pause søgeord.

fnvigtigste() {
til num i1..=10 {
hvis antal == 5 {
pause; // Afslut sløjfe, når tallet er lig med 5
 }
println!("{}", antal); // udskriv tallene 1 til 4
 }
}

Det hvis statement specificerer, at løkken skal afsluttes, når jeg variabel er lig med fem.

Brug Rusts kontrolstrukturer med datatyper til at mestre sproget

Rust giver disse fleksible kontrolstrukturer til operationer på indbyggede og brugerdefinerede datatyper. Du kan bruge disse kontrolstrukturer til at operere på sammensatte og sammensatte datastrukturer som arrays, vektorer, struct og enums.

Rust giver også strukturer. Strukturer er datastrukturer, der grupperer relaterede værdier i et enkelt objekt. De ligner klasser i objektorienterede sprog, og du kan endda definere metoder på dem.