Hvordan du bruker kamputtalelser i rust

En klassisk konstruksjon støttes av de fleste programmeringsspråk, ellers kjent som Switch -setningen. Selv om det tar noen få syntaks og forskjellig formatering, lar det oss samsvare med en spesifikk sak eller tilstand og ta den nødvendige handlingen på forskjellige språk.

I rust implementerer samsvarset nøkkelordet syntaksen for bryterfeltet. La oss utforske hvordan vi bruker kampserklæringen i rust.

Kampserklæring i rust

Vi starter med søkeordkampen, og sammenligner deretter variabelen for å bruke kampkonstruksjonen. Vi åpner deretter kamporganet, som tar saken som en "matchet" verdi mot den spesifiserte variabelenes verdi.

Syntaksen er som vist nedenfor:

Match variabel
verdi => // Gjør dette
Value2 => // Gjør dette

Tenk på eksemplet nedenfor som samsvarer med en enkelt sak:

fn main ()
La alder = 18;
Match alder
18 => println!("Hei!"),
_ => println!("Utilgjengelig")

I forrige eksempel starter vi med å initialisere variabel alder. Deretter bruker vi kampserklæringen for å sjekke om alderen er lik 18; Hvis det er sant, skriver vi ut “Hei”. Hvis variabelenes verdi ikke stemmer overens med 18, skriver vi ut "uoppnåelig".

Understrekene viser i dette tilfellet håndtaket til andre udefinerte tilfeller.

Den forrige koden skal returnere som følger:

For å matche flere verdier, kan du bruke røroperatøren, som vist i eksemplet nedenfor:

fn main ()
La alder = 18;
Match alder
18 | 19 | 20 | 21 | 22 => println!("Hei!"),
_ => println!("Utilgjengelig")

Dette bør sjekke om verdien på variabelen er lik 18,19,20, 21 eller 22. Hvis det er sant, utfører den den spesifiserte blokken.

For å matche en rekke verdier, kan du bruke rekkevidden som vist nedenfor:

fn main ()
La alder = 18;
Match alder
18… = 22 => println!("Hei!"),
_ => println!("Utilgjengelig")

Det forrige eksemplet skal samsvare med verdiene mellom 18 og 22, inkludert.

Husk at kampoperatøren ikke er begrenset til heltalltyper. Du kan matche for strengverdier eller boolske typer som vist i eksemplet nedenfor:

fn main ()
La boolsk = sant;
La aktiv = matche boolsk
falsk => 0,
True => 1,
;
Println!("Aktiv: ", aktiv)

Det forrige eksemplet bruker en boolsk type for å se etter matchende saker. Merk at vi tildeler en verdi i stedet for å skrive ut en verdi til konsollen.

For å matche en streng, kan vi gjøre følgende:

fn main ()
La streng = "Hei";
Match String
"Hei" => println!("Hei tilbake!"),
"Hei" => println!("Ingen hei tilbake!"),
_ => println!("Ukjent hilsen!")
;

Den forrige koden skal skrive ut:

Konklusjon

Denne opplæringen dekker kampserklæringen i Rust og hvordan vi kan bruke den til å sammenligne forskjellige tilfeller. I tillegg diskuterte vi hvordan samsvars -nøkkelordet implementerer syntaks for bryteresaken og ga eksempler. Vi håper du fant denne artikkelen nyttig. Sjekk de andre Linux -hint -artiklene for flere tips og informasjon.