Enums och mönstermatchning i rost

Rust tillhandahåller olika datatyper för att utföra operationer, från grundläggande datatyper som strängar, heltal och flytande peka nummer till sammansatta datatyper som vektorer och matriser till sammansatta datatyper som strukturer och uppräkningar.

Enums (uppräkningar) är en datatyp som tillåter representation av en fast uppsättning värden, som veckodagar och regnbågens färg. Uppräkningar är praktiska när de möjliga värdena för en variabel är begränsade och kända.

Definiera enums i rost

Att deklarera enums i Rust liknar deklarera uppräkningar i C#. Du kommer att använda uppräkning nyckelord efter namnet och en uppsättning lockiga hängslen för att definiera uppräkningar. Du kan definiera möjliga varianter (entiteter) inom de lockiga klammerparenteserna med ett kommatecken som avgränsare.

Här är en uppräkning för veckodagarna:

uppräkningVeckodag {
 måndag,
 tisdag,
 onsdag,
 torsdag,
 Fredag,
 lördag,
 söndag,
}

De Veckodag enum representerar veckodagarna. De varianter är namnen på dagen och har inga associerade värden. Dessutom kan varianterna av din enum vara vilken som helst Rostdatatyp.

Du kan komma åt varianter genom att ange variantnamnet med sökvägseparatorn (::) på enum.

låta dag = veckodag:: måndag;
// statiskt skriven version av variabeln `day`
låta dag: veckodag = veckodag:: måndag;

Koden anger att du vill komma åt måndag variant av Weekday enum.

Varianter och diskriminanter av enums

Varianterna av en enum är associerade med heltalsvärden som kallas diskriminerande. Som standard börjar diskriminantvärdena på noll och ökas med 1 för efterföljande varianter; Det är dock möjligt att ange anpassade diskriminantvärden för varje variant.

Här är ett exempel på Weekday enum med värdetilldelade varianter.

uppräkningVeckodag {
 måndag = 1,
 tisdag = 2,
 onsdag = 3,
 Torsdag = 4,
 fredag ​​= 5,
 lördag = 6,
 söndag = 7,
}

Weekday enum har sju varianter som representerar varje dag i veckan, och varje dag har ett värde (kallad diskriminant) tilldelat dem. Varianterna är i ordningen första till sista dagen i veckan.

Du kan komma åt diskriminantvärdet med hjälp av variantnamnet.

fnhuvud() {
println!("Måndag: {}", Vardag:: Måndag somi32);
println!("Tisdag: {}", Vardag:: Tisdag somi32);
println!("Onsdag: {}", Vardag:: Onsdag somi32);
println!("Torsdag: {}", Vardag:: Torsdag somi32);
println!("Fredag: {}", Vardag:: Fredag somi32);
println!("Lördag: {}", Vardag:: Lördag somi32);
println!("Söndag: {}", Vardag:: Söndag somi32);
}

De println! makro används för att skriva ut diskriminanterna. Varje println! makroanrop tar två argument: en formatsträng och ett värde. Formatsträngen anger hur utdata ska formateras; värdet är det faktiska värdet som skrivs ut.

I det här fallet är formatsträngen en bokstavlig sträng som innehåller veckodagens namn, och värdet är enumvarianten med en explicit cast till i32 heltalstyp.

Den explicita casten till i32 är nödvändig eftersom Rust enums representeras som heltal, men den specifika heltalstypen beror på storleken på enumet. Som standard tilldelar Rust den minsta heltalstypen som kan representera alla diskriminanter i enumet. Men i det här fallet vill du skriva ut värdena som i32-heltal, så du måste casta dem explicit.

Här är resultatet från att köra huvud fungera:

Mönster som matchar i rost

Mönstermatchning är en rostkontrollstruktur som är användbar för att identifiera datamönster. Mönstermatchning gör det möjligt att skriva kortfattad och effektiv kod medan du arbetar med avancerade datastrukturer eller utföra komplexa operationer.

Du kommer att använda match nyckelord följt av => separator för mönstret respektive operationen för mönstret. Mönstret kan vara vilket Rust-uttryck som helst, inklusive bokstaver, variabler och funktionsanrop.

Här är ett exempel på matchning:

fnhuvud(){
låta x = 5;
match x {
1 => println!("ett"),
2 => println!("två"),
3 => println!("tre"),
// körs om inget av mönstren matchar
 _ => println!("något annat"),
 }
}

De huvud funktion matchar x mot flera mönster och skriver sedan ut värdet baserat på värdet på x. Understrecksmönstret (_) är ett jokerteckenmönster som används som en catch-all för ärenden som inte explicit hanteras.

Uppräkningar och mönstermatchning

Uppräkningar och mönstermatchning är användbara för att uttrycka och arbeta med avancerade datastrukturer på ett typsäkert och effektivt sätt. Du kan använda uppräkningar för att definiera en fast uppsättning värden och mönstermatchning för att arbeta med dessa värden.

Här är en uppräkning av färgerna i en regnbåge:

uppräkningRegnbåge {
 Röd,
 Orange,
 Gul,
 Grön,
 Blå,
 Indigo,
 Violett,
}

Varje variant av Regnbåge enum representerar en färg på regnbågen. Du kan använda mönstermatchning med matchsatsen för att matcha mönster mot varianten för att styra programmets flöde baserat på regnbågens färg.

Här är en funktion som tar in färgvarianten från Rainbow enum och skriver ut ett meddelande baserat på färgen.

fnprint_color(färg: Rainbow) {
match Färg {
 Regnbåge:: Röd => println!("Färgen är röd!"),
 Rainbow:: Orange => println!("Färgen är orange!"),
 Regnbåge:: Gul => println!("Färgen är gul!"),
 Regnbåge:: Grön => println!("Färgen är grön!"),
 Regnbåge:: Blå => println!("Färgen är blå!"),
 Rainbow:: Indigo => println!("Färgen är indigo!"),
 Rainbow:: Violet => println!("Färgen är violett!"),
 }
}
fnhuvud() {
låta färg = Regnbåge:: Blå;
 print_color (färg);
}

Du kanske får varianter konstrueras aldrig eller liknande varningar när du försöker köra ovanstående kod eftersom de andra varianterna förutom den blå varianten aldrig konstruerades i den här koden. Så i det här fallet kan du säkert ignorera dessa varningar eftersom det är avsiktligt.

De print_color funktionen tar in en färgparameter av typen Rainbow enum. Matchningsförklaringen matchar färgen från en svit av färger som nås via variantnamnen. Och slutligen skrivs meddelandet ut baserat på den matchade färgen.

Du kan använda mönstermatchning för komplexa operationer som flera returvärden baserat på ett villkor.

fnberäkna_våglängd(färg: Regnbåge) -> u32 {
match Färg {
 Regnbåge:: Röd => 700,
 Rainbow:: Orange => 590,
 Regnbåge:: Gul => 570,
 Regnbåge:: Grön => 510,
 Regnbåge:: Blå => 475,
 Rainbow:: Indigo => 445,
 Rainbow:: Violet => 400,
 }
}

De beräkna_våglängd funktionen tar in en färgvariant av typen Rainbow enum som en parameter och returnerar ett osignerat 32-bitars heltal som är våglängden på färgen som matchar mönstret.

Rost ger också strukturer för att skapa anpassade typer

Enums är praktiska för att definiera anpassade typer för flera operationer, särskilt i fall där fälten är kända och bestämda.

Rust tillhandahåller också strukturer som du kan använda för att skapa anpassade typer med namngivna fält. Till skillnad från enums tillåter strukturer dig att definiera fält av olika typer som du kan komma åt och ändra individuellt.