Rostskyddsstrukturer och hur man använder dem

Kontrollstrukturer är en programmeringskonstruktion som låter dig styra flödet av exekvering i dina program. Kontrollstrukturer låter dig ange instruktioner som endast ska köras om vissa villkor är uppfyllda.

Rusts kontrollstrukturer är avgörande för att hantera programflödet, vilket möjliggör effektiv kodexekvering samtidigt som komplexa uppgifter förenklas till mindre, återanvändbara komponenter.

Rostvillkorliga uttalanden

Villkorssatser är konstruktioner som låter dig köra kod baserat på villkor. Villkorliga uttalanden är användbara för beslutsfattande eftersom programmets genomförande beror på om tillståndet utvärderas till Sann eller falsk. Rost ger om, annan, och match uttalanden för beslutsfattande.

I Rust-program, den om påstående testar om ett visst tillstånd utvärderas till sant. Om det gör det, kör programmet det tillhörande kodblocket. Om villkoret utvärderas falskt, hoppar programmet över det kodblocket och går vidare till nästa sats eller kör annan meddelandeblock om det finns något.

De match statement är en kraftfull kontrollflödeskonstruktion som tillåter ett program att matcha värden mot en serie mönster och exekvera kod baserat på det matchande mönstret.

Rust's if-uttalanden

Du kommer att deklarera om uttalanden i dina Rust-program med om nyckelord följt av ett villkor:

om skick {
// kod som ska köras om villkoret är sant
}

Här är ett exempel på hur du kan använda en if-sats i dina Rust-program:

fnhuvud() {
låta x = 15;
om x > 10 {
println!("x är större än 10");
 }
}

De x variabeln innehåller ett 32-bitars heltal, och if-satsen kontrollerar om värdet på x är större än tio innan kodblocket körs som skriver ut det.

Rusts andra uttalanden

Du kommer att använda annan nyckelord för att exekvera ett kodblock när du förutser att en om påstående skulle bedömas som falskt.

om skick {
// kod som ska köras om villkoret är sant
} annan {
// kod som ska köras om villkoret är falskt
}

Här är ett exempel var x inte är större än 10, den om uttalande utvärderar falsk, och en annan uttalande körs.

fnhuvud(){
låta x = 5;
om x > 10 {
println!("x är större än 10");
 } annan {
println!("x är inte större än 10");
 }
}

Eftersom x är 5 och 5 inte är större än 10, hoppar programmet över om blockera och kör annan blockera.

Rusts matchuttalanden

Du kommer att använda match nyckelord för komplext beslutsfattande för att kontrollera en serie mönster och exekvera kod baserat på mönstermatchningar. Matchpåståenden liknar switch-satser i C#, Go och C++.

Här är strukturen för ett Rust-matchningsförklaring:

match värde {
 mönster1 => {
// kod som ska köras om värdet matchar mönster1
 },
 mönster2 => {
// kod som ska köras om värdet matchar mönster2
 },
// etc.
}

Så här kan du använda matchningssatser i dina program:

låta betyg = 'B';
match betyg {
'A' => println!("Utmärkt arbete!"),
'B' => println!("Bra jobbat."),
'C' => println!("Du kunde göra bättre."),
 _ => println!("Det är inte ett giltigt betyg."),
}

De kvalitet variabel är ett tecken och match satsen kontrollerar vilka av tecknen som utvärderas till värdet av gradvariabeln innan koden exekveras efter =>-operatorn. Du kan använda understrecksmönstret (_) för att matcha värden som inte matchar andra mönster (standardmönstret).

Slingor i Rust

Slingor är en grundläggande konstruktion som används för repetitiva uppgifter som webbskrapning och andra automatiserade åtgärder. Rust ger olika typer av slingor, bl.a medan slingor, för slingor och slinga slinga.

Rust's while Loops

Medans loopar upprepar ett kodblock så länge som ett specificerat villkor utvärderas sant. Innan du anger villkoret ska du ange while-slingor i Rust med medan nyckelord.

medan skick {
// kod att köra
}

Villkoret ska vara ett booleskt uttryck som bestämmer slingans fortsättning. När villkoret utvärderas falskt avslutas slingan.

Här är ett exempel på en Rust while-loop som skriver ut nummer från ett till fem.

fnhuvud() {
låtamut jag = 1;
medan jag <= 5 {
println!("{}"i);
 jag += 1;
 }
}

While-slingan i huvud funktionen går genom siffrorna ett till fem samtidigt som den ökar i variabel med en tills i variabeln är större än fem, där slingan slutar.

Slingan Loop

De slinga nyckelord skapar en oändlig loop tills du anger en utgång med ha sönder nyckelord.

slinga {
// kod att köra
om skick {
ha sönder;
 }
}

Koden i slinga blocket kommer att fortsätta köras tills loopen stöter på en ha sönder nyckelord.

Här är ett exempel på hur du använder slinga loop för att skriva ut nummer ett till fem innan du anger ha sönder nyckelord för utgången.

fnhuvud() {
låtamut jag = 1;
slinga {
println!("{}"i);
 jag += 1;
om jag > 5 {
ha sönder;
 }
 }
}

De huvud funktionen exekverar slingan, och om uttalandet ökar i variabel. De om uttalande anger slingavslutningen när i variabeln överstiger fem.

Rust’s for Loops

I Rust, för loopar iterera genom ett intervall eller en samling värden. Du kommer att använda för nyckelord för att starta en for-loop, innan du anger intervallet eller samlingen den verkar på.

för variabel i range {
// kod att köra
}

De räckvidd är ett uttryck som utvärderas till en sekvens av värden, och variabeln är en variabel som tar på sig varje värde i sekvensen i tur och ordning. Kodblocket kommer att köras en gång för varje värde i sekvensen.

Här är ett exempel på en for-loop som skriver ut värden från ett till tio.

fnhuvud() {
för i i1..=10 {
println!("{}"i);
 }
}

Slingan itererar genom värdena från 1 till 10. Vid varje iteration håller variabeln (i) nästa värde, som println! makro skrivs sedan ut.

Du kan använda Fortsätta nyckelord för att hoppa över värden i for-loops. Så här kan du hoppa över de jämna siffrorna när du använder ett intervall:

fnhuvud() {
för num i1..=10 {
om antal % 2 == 0 {
Fortsätta; // hoppa över jämna nummer
 }
println!("{}", antal); // skriv udda tal
 }
}

De om uttalandet använder Fortsätta nyckelord för att ange att slingan ska hoppa över tal som är delbara med två.

Dessutom kan du avsluta en for-loop med ha sönder nyckelord. Slingan avslutas när den möter ha sönder nyckelord.

fnhuvud() {
för num i1..=10 {
om antal == 5 {
ha sönder; // avsluta loop när talet är lika med 5
 }
println!("{}", antal); // skriv ut nummer 1 till 4
 }
}

De om uttalande anger att slingan ska avslutas när i variabel är lika med fem.

Använd Rusts kontrollstrukturer med datatyper för att bemästra språket

Rust tillhandahåller dessa flexibla kontrollstrukturer för operationer på inbyggda och anpassade datatyper. Du kan använda dessa kontrollstrukturer för att arbeta på sammansatta och sammansatta datastrukturer som arrayer, vektorer, struktur och enums.

Rost ger också strukturer. Strukturer är datastrukturer som grupperar relaterade värden i ett enda objekt. De liknar klasser i objektorienterade språk, och du kan till och med definiera metoder på dem.