Start din Rust-programmeringskarriere ved å lære om disse grunnleggende språkkunnskapene.

Kontrollstrukturer er en programmeringskonstruksjon som lar deg kontrollere flyten av utførelse i programmene dine. Kontrollstrukturer lar deg spesifisere instruksjoner som bare skal kjøres hvis visse betingelser er oppfylt.

Rusts kontrollstrukturer er avgjørende for å administrere programflyten, noe som muliggjør effektiv kodekjøring samtidig som komplekse oppgaver forenkles til mindre, gjenbrukbare komponenter.

Rustbetingelser

Betingede setninger er konstruksjoner som lar deg kjøre kode basert på betingelser. Betingede utsagn er nyttige for beslutningstaking siden programmets utførelse avhenger av om tilstanden evalueres til ekte eller falsk. Rust gir hvis, ellers, og kamp uttalelser for beslutningstaking.

I Rust-programmer er hvis utsagn tester om en bestemt tilstand vurderes til å være sann. Hvis den gjør det, kjører programmet den tilhørende kodeblokken. Hvis tilstanden evalueres som falsk, hopper programmet over den kodeblokken og går videre til neste setning eller kjører

instagram viewer
ellers erklæringsblokk hvis det er noen.

De kamp statement er en kraftig kontrollflytkonstruksjon som lar et program matche verdier mot en rekke mønstre og kjøre kode basert på matchende mønster.

Rust's if-uttalelser

Du vil erklære hvis uttalelser i Rust-programmene dine med hvis nøkkelord etterfulgt av en betingelse:

hvis betingelse {
// kode som skal utføres hvis betingelsen er sann
}

Her er et eksempel på hvordan du kan bruke en if-setning i Rust-programmene dine:

fnhoved-() {
la x = 15;
hvis x > 10 {
println!("x er større enn 10");
 }
}

De x variabelen har et 32-bits heltall, og if-setningen sjekker om verdien av x er større enn ti før du kjører kodeblokken som skriver den ut.

Rusts andre uttalelser

Du vil bruke ellers nøkkelord for å utføre en kodeblokk når du forventer at en hvis utsagn vil vurderes som falsk.

hvis betingelse {
// kode som skal utføres hvis betingelsen er sann
} ellers {
// kode som skal utføres hvis betingelsen er falsk
}

Her er et eksempel hvor x ikke er større enn 10, den hvis uttalelse vurderer falsk, og en ellers uttalelsen kjører.

fnhoved-(){
la x = 5;
hvis x > 10 {
println!("x er større enn 10");
 } ellers {
println!("x er ikke større enn 10");
 }
}

Siden x er 5 og 5 ikke er større enn 10, hopper programmet over hvis blokkere og utfører ellers blokkere.

Rusts kamperklæringer

Du vil bruke kamp nøkkelord for kompleks beslutningstaking for å sjekke en rekke mønstre og utføre kode basert på mønstertreff. Matchutsagnene ligner på bytte utsagn i C#, Go og C++.

Her er strukturen til en Rust-match-erklæring:

kamp verdi {
 mønster1 => {
// kode som skal utføres hvis verdien samsvarer med mønster1
 },
 mønster2 => {
// kode som skal utføres hvis verdien samsvarer med mønster2
 },
// etc.
}

Slik kan du bruke samsvarsuttalelser i programmene dine:

la karakter = 'B';
kamp karakter {
'EN' => println!("Fantastisk arbeid!"),
'B' => println!("Godt jobbet."),
'C' => println!("Du kunne gjort det bedre."),
 _ => println!("Det er ikke en gyldig karakter."),
}

De karakter variabel er et tegn, og kamp setningen sjekker for hvilke av tegnene som evalueres til verdien av karaktervariabelen før koden kjøres etter =>-operatoren. Du kan bruke understrekingsmønsteret (_) for å matche verdier som ikke samsvarer med andre mønstre (standardmønsteret).

Løkker i Rust

Løkker er en grunnleggende konstruksjon som brukes til repeterende oppgaver som nettskraping og andre automatiserte handlinger. Rust gir ulike typer løkker, bl.a samtidig som løkker, til løkker, og Løkke Løkke.

Rust's while Loops

Mens løkker gjentar en kodeblokk så lenge en spesifisert tilstand evalueres som sann. Før du spesifiserer tilstanden, spesifiserer du mens-løkker i Rust med samtidig som nøkkelord.

samtidig som betingelse {
// kode for å kjøre
}

Betingelsen skal være et boolsk uttrykk som bestemmer løkkens fortsettelse. Når tilstanden evalueres som falsk, avsluttes løkken.

Her er et eksempel på en Rust while-løkke som skriver ut tall fra én til fem.

fnhoved-() {
lamut jeg = 1;
samtidig som jeg <= 5 {
println!("{}", Jeg);
 jeg += 1;
 }
}

Mens løkken i hoved- funksjonen går gjennom tallene en til fem mens den øker Jeg variabel med en til Jeg variabelen er større enn fem, der sløyfen avsluttes.

Løkken Loop

De Løkke nøkkelordet oppretter en uendelig sløyfe til du oppgir en utgang med gå i stykker nøkkelord.

Løkke {
// kode for å kjøre
hvis betingelse {
gå i stykker;
 }
}

Koden i Løkke blokk vil fortsette å kjøre til loopen møter en gå i stykker nøkkelord.

Her er et eksempel på bruk av Løkke løkke for å skrive ut nummer én til fem før du spesifiserer gå i stykker nøkkelord for utgangen.

fnhoved-() {
lamut jeg = 1;
Løkke {
println!("{}", Jeg);
 jeg += 1;
hvis jeg > 5 {
gå i stykker;
 }
 }
}

De hoved- funksjonen utfører løkken, og hvis uttalelsen øker Jeg variabel. De hvis setningen spesifiserer sløyfeavslutningen når Jeg variabel overstiger fem.

Rust's for Loops

I Rust, for loops iterere gjennom et område eller en samling av verdier. Du vil bruke til nøkkelord for å starte en for-løkke, før du spesifiserer området eller samlingen den virker på.

til variabel i område {
// kode for å kjøre
}

De område er et uttrykk som evalueres til en sekvens av verdier, og variabelen er en variabel som tar på seg hver verdi i sekvensen etter tur. Kodeblokken kjøres én gang for hver verdi i sekvensen.

Her er et eksempel på en for-løkke som skriver ut verdier fra én til ti.

fnhoved-() {
til Jeg i1..=10 {
println!("{}", Jeg);
 }
}

Løkken itererer gjennom verdiene fra 1 til 10. På hver iterasjon holder variabelen (i) den neste verdien, som println! makroen skrives ut.

Du kan bruke Fortsette nøkkelord for å hoppe over verdier i for-løkker. Slik kan du hoppe over partallene når du opererer på en rekkevidde:

fnhoved-() {
til num i1..=10 {
hvis antall % 2 == 0 {
Fortsette; // hoppe over partall
 }
println!("{}", num); // skriv ut oddetall
 }
}

De hvis uttalelsen bruker Fortsette nøkkelord for å spesifisere at løkken skal hoppe over tall som er delelig med to.

I tillegg kan du avslutte en for-loop med gå i stykker nøkkelord. Sløyfen avsluttes ved møte med gå i stykker nøkkelord.

fnhoved-() {
til num i1..=10 {
hvis num == 5 {
gå i stykker; // gå ut av loop når tallet er lik 5
 }
println!("{}", num); // skriv ut tallene 1 til 4
 }
}

De hvis setningen spesifiserer at sløyfen skal avsluttes når Jeg variabel er lik fem.

Bruk Rusts kontrollstrukturer med datatyper for å mestre språket

Rust gir disse fleksible kontrollstrukturene for operasjoner på innebygde og tilpassede datatyper. Du kan bruke disse kontrollstrukturene til å operere på sammensatte og sammensatte datastrukturer som arrays, vektorer, struct og enums.

Rust gir også strukturer. Strukturer er datastrukturer som grupperer relaterte verdier i et enkelt objekt. De ligner på klasser i objektorienterte språk, og du kan til og med definere metoder på dem.