Opsommingen en patroonafstemming in roest

Rust biedt verschillende gegevenstypen om bewerkingen uit te voeren, van basisgegevenstypen zoals tekenreeksen, gehele getallen en zwevend puntnummers tot samengestelde gegevenstypen zoals vectoren en arrays tot samengestelde gegevenstypen zoals structuren en opsommingen.

Enums (opsommingen) is een gegevenstype waarmee een vaste reeks waarden kan worden weergegeven, zoals de dagen van de week en de kleur van de regenboog. Enums zijn handig wanneer de mogelijke waarden voor een variabele beperkt en bekend zijn.

Enums definiëren in Rust

Het declareren van opsommingen in Rust is vergelijkbaar met opsommingen declareren in C#. Je gebruikt de opsomming trefwoord na de naam en een set accolades om opsommingen te definiëren. U kunt de mogelijke varianten (entiteiten) binnen de accolades definiëren met een komma als scheidingsteken.

Hier is een opsomming van de dagen van de week:

opsommingWeekdag {
 Maandag,
 Dinsdag,
 Woensdag,
 Donderdag,
 Vrijdag,
 Zaterdag,
 Zondag,
}

De Weekdag enum vertegenwoordigt de dagen van de week. De varianten zijn de namen van de dag en hebben geen bijbehorende waarden. Ook kunnen de varianten van uw opsomming elk zijn Roest gegevenstype.

U krijgt toegang tot varianten door de naam van de variant op te geven met behulp van de padscheidingstekenoperator (::) op de opsomming.

laten dag = weekdag:: maandag;
// statisch getypeerde versie van de variabele `dag`
laten dag: weekdag = weekdag:: maandag;

De code geeft aan dat u toegang wilt tot de Maandag variant van de weekdag opsomming.

Varianten en discriminanten van Enums

De varianten van een enum worden geassocieerd met integer-waarden genoemd discriminerend. Standaard beginnen de discriminantwaarden bij nul en worden voor volgende varianten met 1 verhoogd; het is echter mogelijk om voor elke variant aangepaste discriminantwaarden op te geven.

Hier is een voorbeeld van de doordeweekse opsomming met varianten met toegewezen waarde.

opsommingWeekdag {
 Maandag = 1,
 dinsdag = 2,
 woensdag = 3,
 donderdag = 4,
 vrijdag = 5,
 zaterdag = 6,
 zondag = 7,
}

De opsomming van weekdagen heeft zeven varianten die elke dag van de week vertegenwoordigen, en aan elke dag is een waarde (de discriminant genoemd) toegewezen. De varianten staan ​​in de volgorde van de eerste tot de laatste dag van de week.

U hebt toegang tot de discriminantwaarde met behulp van de variantnaam.

fnvoornaamst() {
println!("Maandag: {}", Weekdag:: maandag alsi32);
println!("Dinsdag: {}", Weekdag:: dinsdag alsi32);
println!("Woensdag: {}", Weekdag:: woensdag alsi32);
println!("Donderdag: {}", Weekdag:: donderdag alsi32);
println!("Vrijdag: {}", Weekdag:: vrijdag alsi32);
println!("Zaterdag: {}", Weekdag:: zaterdag alsi32);
println!("Zondag: {}", Weekdag:: Zondag alsi32);
}

De println! macro wordt gebruikt om de discriminanten af ​​te drukken. Elke println! macro-aanroep heeft twee argumenten: een opmaaktekenreeks en een waarde. De opmaaktekenreeks geeft aan hoe de uitvoer moet worden opgemaakt; de waarde is de werkelijke waarde die wordt afgedrukt.

In dit geval is de opmaaktekenreeks een letterlijke tekenreeks die de naam van de weekdag bevat, en de waarde is de enum-variant met een expliciete cast naar de i32 geheel getal.

De expliciete cast naar i32 is nodig omdat Rust-enums worden weergegeven als gehele getallen, maar het specifieke integer-type hangt af van de grootte van de enum. Standaard wijst Rust het kleinste gehele type toe dat alle discriminanten in de enum kan vertegenwoordigen. Maar in dit geval wilt u de waarden afdrukken als i32 gehele getallen, dus u moet ze expliciet casten.

Hier is het resultaat van het uitvoeren van de voornaamst functie:

Patronen die overeenkomen in roest

Patroonvergelijking is een Rust-besturingsstructuurconstructie die nuttig is voor het identificeren van gegevenspatronen. Patroonherkenning maakt het mogelijk om beknopte en efficiënte code te schrijven tijdens het werken met geavanceerde datastructuren of het uitvoeren van complexe operaties.

Je gebruikt de overeenkomst trefwoord gevolgd door de => scheidingsteken voor respectievelijk het patroon en de bewerking voor het patroon. Het patroon kan elke Rust-expressie zijn, inclusief letterlijke waarden, variabelen en functieaanroepen.

Hier is een voorbeeld van een overeenkomstverklaring:

fnvoornaamst(){
laten x= 5;
overeenkomst X {
1 => println!("een"),
2 => println!("twee"),
3 => println!("drie"),
// wordt uitgevoerd als geen van de patronen overeenkomt
 _ => println!("iets anders"),
 }
}

De voornaamst functie komt overeen X tegen verschillende patronen en drukt vervolgens de waarde af op basis van de waarde van x. Het underscore-patroon (_) is een jokertekenpatroon dat wordt gebruikt als verzamelnaam voor zaken die niet expliciet worden afgehandeld.

Opsommingen en patroonafstemming

Opsommingen en patroonvergelijking zijn handig voor het uitdrukken en werken met geavanceerde gegevensstructuren op een typeveilige en efficiënte manier. U kunt opsommingen gebruiken om een ​​vaste reeks waarden en patroonovereenkomsten te definiëren om met die waarden te werken.

Hier is een opsomming van de kleuren in een regenboog:

opsommingRegenboog {
 Rood,
 Oranje,
 Geel,
 Groente,
 Blauw,
 Indigo,
 Paars,
}

Elke variant van de Regenboog enum vertegenwoordigt een kleur van de regenboog. U kunt patroonvergelijking gebruiken met de overeenkomstverklaring om patronen te vergelijken met de variant om de stroom van het programma te regelen op basis van de kleur van de regenboog.

Hier is een functie die de kleurvariant uit de Rainbow-enum overneemt en een bericht afdrukt op basis van de kleur.

fnafdruk_kleur(kleur: Regenboog) {
overeenkomst kleur {
 Regenboog:: Rood => println!("De kleur is rood!"),
 Regenboog:: Oranje => println!("De kleur is oranje!"),
 Regenboog:: Geel => println!("De kleur is geel!"),
 Regenboog:: Groen => println!("De kleur is groen!"),
 Regenboog:: Blauw => println!("De kleur is blauw!"),
 Regenboog:: Indigo => println!("De kleur is indigo!"),
 Regenboog:: Violet => println!("De kleur is violet!"),
 }
}
fnvoornaamst() {
laten kleur = Regenboog:: Blauw;
 print_color (kleur);
}

Je krijgt misschien varianten worden nooit geconstrueerd of vergelijkbare waarschuwingen wanneer u de bovenstaande code probeert uit te voeren, omdat de andere varianten behalve de blauwe variant nooit in deze code zijn gemaakt. In dit geval kunt u deze waarschuwingen dus veilig negeren, aangezien het opzettelijk is.

De afdruk_kleur functie neemt een kleurparameter van het Rainbow enum-type op. De overeenkomstverklaring komt overeen met de kleur uit een reeks kleuren die toegankelijk zijn via de variantnamen. En tot slot wordt het bericht afgedrukt op basis van de overeenkomende kleur.

U kunt patroonvergelijking gebruiken voor complexe bewerkingen, zoals meerdere geretourneerde waarden op basis van een voorwaarde.

fnbereken_golflengte(kleur: Regenboog) -> u32 {
overeenkomst kleur {
 Regenboog:: Rood => 700,
 Regenboog:: Oranje => 590,
 Regenboog:: Geel => 570,
 Regenboog:: Groen => 510,
 Regenboog:: Blauw => 475,
 Regenboog:: Indigo => 445,
 Regenboog:: Violet => 400,
 }
}

De bereken_golflengte functie neemt een kleurvariant van het opsommingstype Rainbow als parameter en retourneert een niet-ondertekend 32-bits geheel getal dat de golflengte is van de kleur die overeenkomt met het patroon.

Rust biedt ook structuren voor het maken van aangepaste typen

Enums zijn handig voor het definiëren van aangepaste typen voor verschillende bewerkingen, vooral in gevallen waarin de velden bekend en definitief zijn.

Rust biedt ook structs die u kunt gebruiken om aangepaste typen met benoemde velden te maken. In tegenstelling tot opsommingen, kunt u met structs velden van verschillende typen definiëren die u afzonderlijk kunt openen en wijzigen.