Enums og mønstertilpasning i rust

Rust gir forskjellige datatyper for å utføre operasjoner, fra grunnleggende datatyper som strenger, heltall og flytende pek tall til sammensatte datatyper som vektorer og matriser til sammensatte datatyper som strukturer og oppregninger.

Enums (oppregninger) er en datatype som tillater representasjon av et fast sett med verdier, som ukedagene og fargen på regnbuen. Enums er nyttige når de mulige verdiene for en variabel er begrenset og kjent.

Definere enums i rust

Å erklære enums i Rust ligner på erklære enums i C#. Du vil bruke enum nøkkelord etter navnet og et sett med krøllete klammeparenteser for å definere oppregninger. Du kan definere mulige varianter (entiteter) innenfor de krøllete klammeparentesene med et komma som skilletegn.

Her er en oversikt over ukedagene:

enumUkedag {
 Mandag,
 Tirsdag,
 Onsdag,
 Torsdag,
 Fredag,
 Lørdag,
 Søndag,
}

De Ukedag enum representerer ukedagene. De

varianter er dagens navn og har ingen tilknyttede verdier. Variantene av enumen din kan også være hvilken som helst Rustdatatype.

Du kan få tilgang til varianter ved å spesifisere variantnavnet ved å bruke baneseparatoren (::) på enum.

la dag = ukedag:: mandag;
// statisk skrevet versjon av 'day'-variabelen
la dag: ukedag = ukedag:: mandag;

Koden spesifiserer at du vil ha tilgang til mandag variant av Weekday enum.

Varianter og diskriminanter av Enums

Variantene av en enum er assosiert med heltallsverdier kalt diskriminerende. Som standard starter diskriminantverdiene på null og økes med 1 for påfølgende varianter; Det er imidlertid mulig å spesifisere egendefinerte diskriminantverdier for hver variant.

Her er et eksempel på ukedagsopptellingen med verditildelte varianter.

enumUkedag {
 mandag = 1,
 tirsdag = 2,
 onsdag = 3,
 Torsdag = 4,
 fredag ​​= 5,
 Lørdag = 6,
 søndag = 7,
}

Weekday enum har syv varianter som representerer hver dag i uken, og hver dag har en verdi (kalt diskriminant) tildelt dem. Variantene er i rekkefølgen fra første til siste dag i uken.

Du kan få tilgang til diskriminantverdien ved å bruke variantnavnet.

fnhoved-() {
println!("Mandag: {}", Ukedag:: Mandag somi32);
println!("tirsdag: {}", Ukedag:: Tirsdag somi32);
println!("Onsdag: {}", Ukedag:: Onsdag somi32);
println!("Torsdag: {}", Ukedag:: Torsdag somi32);
println!("Fredag: {}", Ukedag:: Fredag somi32);
println!("Lørdag: {}", Ukedag:: Lørdag somi32);
println!("Søndag: {}", Ukedag:: Søndag somi32);
}

De println! makro brukes til å skrive ut diskriminantene. Hver utskrift! makroanrop tar to argumenter: en formatstreng og en verdi. Formatstrengen spesifiserer hvordan utdata skal formateres; verdien er den faktiske verdien som blir skrevet ut.

I dette tilfellet er formatstrengen en streng bokstavelig som inneholder ukedagens navn, og verdien er enum-varianten med en eksplisitt cast til i32 heltallstype.

Den eksplisitte casten til i32 er nødvendig fordi Rust-enums er representert som heltall, men den spesifikke heltallstypen avhenger av størrelsen på enumen. Som standard tildeler Rust den minste heltallstypen som kan representere alle diskriminantene i enumet. Men i dette tilfellet vil du skrive ut verdiene som i32-heltall, så du må caste dem eksplisitt.

Her er resultatet fra å kjøre hoved- funksjon:

Mønstre som matcher i rust

Mønstertilpasning er en rustkontrollstruktur som er nyttig for å identifisere datamønstre. Mønstertilpasning gjør det mulig å skrive kortfattet og effektiv kode mens du arbeider med avanserte datastrukturer eller utføre komplekse operasjoner.

Du vil bruke kamp nøkkelord etterfulgt av => separator for henholdsvis mønsteret og operasjonen for mønsteret. Mønsteret kan være et hvilket som helst Rust-uttrykk, inkludert bokstaver, variabler og funksjonskall.

Her er et eksempel på samsvarserklæring:

fnhoved-(){
la x = 5;
kamp x {
1 => println!("en"),
2 => println!("to"),
3 => println!("tre"),
// kjører hvis ingen av mønstrene samsvarer
 _ => println!("noe annet"),
 }
}

De hoved- funksjon samsvarer x mot flere mønstre og skriver deretter ut verdien basert på verdien av x. Understrekmønsteret (_) er et jokertegnmønster som brukes som oppsamlingspunkt for saker som ikke eksplisitt behandles.

Enums og mønstertilpasning

Enums og mønstertilpasning er nyttig for å uttrykke og arbeide med avanserte datastrukturer på en typesikker og effektiv måte. Du kan bruke enums til å definere et fast sett med verdier og mønstertilpasning for å jobbe med disse verdiene.

Her er en oversikt over fargene i en regnbue:

enumRegnbue {
 Rød,
 Oransje,
 Gul,
 Grønn,
 Blå,
 Indigo,
 Fiolett,
}

Hver variant av Regnbue enum representerer en farge på regnbuen. Du kan bruke mønstertilpasning med matcherklæringen for å matche mønstre mot varianten for å kontrollere programmets flyt basert på regnbuens farge.

Her er en funksjon som tar inn fargevarianten fra Rainbow enum og skriver ut en melding basert på fargen.

fnprint_color(farge: Rainbow) {
kamp farge {
 Regnbue:: Rød => println!("Fargen er rød!"),
 Regnbue:: Oransje => println!("Fargen er oransje!"),
 Regnbue:: Gul => println!("Fargen er gul!"),
 Regnbue:: Grønn => println!("Fargen er grønn!"),
 Regnbue:: Blå => println!("Fargen er blå!"),
 Rainbow:: Indigo => println!("Fargen er indigo!"),
 Regnbue:: Fiolett => println!("Fargen er fiolett!"),
 }
}
fnhoved-() {
la farge = Regnbue:: Blå;
 print_color (farge);
}

Du kan få varianter blir aldri konstruert eller lignende advarsler når du prøver å kjøre koden ovenfor fordi de andre variantene bortsett fra den blå varianten aldri ble konstruert i denne koden. Derfor, i dette tilfellet, kan du trygt ignorere disse advarslene siden det er med vilje.

De print_color funksjonen tar inn en fargeparameter av typen Rainbow enum. Matcherklæringen samsvarer med fargen fra en serie farger som er tilgjengelig via variantnavnene. Og til slutt skrives meldingen ut basert på den matchede fargen.

Du kan bruke mønstertilpasning for komplekse operasjoner som flere returverdier basert på en betingelse.

fnberegne_bølgelengde(farge: Rainbow) -> u32 {
kamp farge {
 Regnbue:: Rød => 700,
 Regnbue:: Oransje => 590,
 Regnbue:: Gul => 570,
 Regnbue:: Grønn => 510,
 Regnbue:: Blå => 475,
 Rainbow:: Indigo => 445,
 Regnbue:: Fiolett => 400,
 }
}

De beregne_bølgelengde funksjonen tar inn en fargevariant av Rainbow enum-typen som en parameter og returnerer et usignert 32-bits heltall som er bølgelengden til fargen som samsvarer med mønsteret.

Rust gir også strukturer for å lage tilpassede typer

Enums er nyttige for å definere egendefinerte typer for flere operasjoner, spesielt i tilfeller der feltene er kjente og bestemte.

Rust gir også strukturer som du kan bruke til å lage egendefinerte typer med navngitte felt. I motsetning til enums, lar strukturer deg definere felt av forskjellige typer som du kan få tilgang til og endre individuelt.