Enums și Pattern Matching în Rust

Rust oferă diverse tipuri de date pentru a efectua operațiuni, de la tipuri de date de bază, cum ar fi șiruri de caractere, numere întregi și flotante numerele punctate pentru tipuri de date compuse, cum ar fi vectori și matrice, pentru tipuri de date compuse, cum ar fi structuri și enumerari.

Enums (enumerări) este un tip de date care permite reprezentarea unui set fix de valori, cum ar fi zilele săptămânii și culoarea curcubeului. Enumerările sunt utile atunci când valorile posibile pentru o variabilă sunt limitate și cunoscute.

Definirea enumerarilor în Rust

Declararea enumerarilor în Rust este similară cu declararea enumărilor în C#. Vei folosi enumerare cuvânt cheie după numele și un set de acolade pentru a defini enumerațiile. Puteți defini variantele (entitățile) posibile în cadrul acoladelor cu o virgulă ca separator.

Iată o enumerare pentru zilele săptămânii:

enumerareZiua săptămânii {
 Luni,
 Marţi,
 Miercuri,
 Joi,
 Vineri,
 Sâmbătă,
 Duminică,
}

The Ziua săptămânii enum reprezintă zilele săptămânii. The variante sunt numele zilei și nu au valori asociate. De asemenea, variantele enumerarii dvs. pot fi oricare Tip de date Rugină.

Puteți accesa variante specificând numele variantei folosind operatorul de separare a căii (::) de pe enumerare.

lăsa zi = Ziua săptămânii:: Luni;
// versiunea tipizată static a variabilei `day`
lăsa zi: Ziua saptamanii = Ziua saptamanii:: Luni;

Codul specifică faptul că doriți să accesați luni varianta enumerarii Weekday.

Variante și discriminatori de enumerare

Variantele unei enumerari sunt asociate cu valori intregi numite discriminant. Implicit, valorile discriminante încep de la zero și sunt incrementate cu 1 pentru variantele ulterioare; cu toate acestea, este posibil să specificați valori discriminante personalizate pentru fiecare variantă.

Iată un exemplu de enumerare Weekday cu variante atribuite valorii.

enumerareZiua săptămânii {
 luni = 1,
 marți = 2,
 miercuri = 3,
 joi = 4,
 vineri = 5,
 Sambata = 6,
 Duminica = 7,
}

Enumerația Weekday are șapte variante reprezentând fiecare zi a săptămânii și fiecare zi are o valoare (numită discriminant) atribuită acestora. Variantele sunt în ordinea primei până la ultima zi a săptămânii.

Puteți accesa valoarea discriminantă folosind numele variantei.

fnprincipal() {
println!(„Luni: {}”, Ziua săptămânii:: Luni la fel dei32);
println!(„Marți: {}”, Ziua săptămânii:: Marți la fel dei32);
println!(„Miercuri: {}”, Ziua săptămânii:: Miercuri la fel dei32);
println!(„Joi: {}”, Ziua săptămânii:: Joi la fel dei32);
println!(„Vineri: {}”, Ziua săptămânii:: Vineri la fel dei32);
println!(„Sâmbătă: {}”, Ziua săptămânii:: Sâmbătă la fel dei32);
println!("Duminică: {}", Ziua săptămânii:: Duminică la fel dei32);
}

The println! macro este folosită pentru a imprima discriminanții. Fiecare println! invocarea macro are două argumente: un șir de format și o valoare. Șirul de format specifică modul de formatare a ieșirii; valoarea este valoarea reală care este imprimată.

În acest caz, șirul de format este un literal șir care conține numele zilei săptămânii, iar valoarea este varianta de enumerare cu o distribuție explicită la i32 tipul întreg.

Distribuția explicită la i32 este necesară deoarece enumerarile Rust sunt reprezentate ca numere întregi, dar tipul întreg specific depinde de dimensiunea enumerarii. În mod implicit, Rust atribuie cel mai mic tip întreg care poate reprezenta toți discriminanții din enumerare. Dar, în acest caz, doriți să imprimați valorile ca numere întregi i32, deci trebuie să le turnați în mod explicit.

Iată rezultatul rulării principal funcţie:

Modele care se potrivesc în rugină

Potrivirea modelelor este o construcție a structurii de control Rust utilă pentru identificarea modelelor de date. Potrivirea modelelor permite scrierea unui cod concis și eficient în timp ce se lucrează cu structuri de date avansate sau efectuarea de operaţii complexe.

Vei folosi Meci cuvânt cheie urmat de => separator pentru model și, respectiv, operația pentru model. Modelul poate fi orice expresie Rust, inclusiv literale, variabile și apeluri de funcție.

Iată un exemplu de declarație de potrivire:

fnprincipal(){
lăsa x = 5;
Meci X {
1 => println!("unu"),
2 => println!("Două"),
3 => println!("Trei"),
// rulează dacă niciunul dintre modele nu se potrivește
 _ => println!("altceva"),
 }
}

The principal potriviri de funcții X față de mai multe modele și apoi imprimă valoarea pe baza valorii lui x. Modelul de subliniere (_) este un model de wild card care este folosit ca un rezumat pentru cazurile care nu sunt tratate în mod explicit.

Enumări și potrivire de modele

Enumerările și potrivirea modelelor sunt utile pentru exprimarea și lucrul cu structuri avansate de date într-un mod sigur și eficient. Puteți folosi enumări pentru a defini un set fix de valori și potrivire de modele pentru a lucra cu acele valori.

Iată o enumerare pentru culorile dintr-un curcubeu:

enumerareCurcubeu {
 Roșu,
 Portocale,
 Galben,
 Verde,
 Albastru,
 Indigo,
 Violet,
}

Fiecare variantă a Curcubeu enum reprezintă o culoare a curcubeului. Puteți utiliza potrivirea modelului cu declarația de potrivire pentru a potrivi modelele cu varianta pentru a controla fluxul programului pe baza culorii curcubeului.

Iată o funcție care preia varianta de culoare din enumerarea Rainbow și tipărește un mesaj bazat pe culoare.

fnprint_color(culoare: Curcubeu) {
Meci culoare {
 Curcubeu:: Roșu => println!(„Culoarea este roșie!”),
 Curcubeu:: Portocaliu => println!(„Culoarea este portocalie!”),
 Curcubeu:: Galben => println!(„Culoarea este galbenă!”),
 Curcubeu:: Verde => println!(„Culoarea este verde!”),
 Curcubeu:: Albastru => println!(„Culoarea este albastră!”),
 Curcubeu:: Indigo => println!(„Culoarea este indigo!”),
 Curcubeu:: Violet => println!(„Culoarea este violeta!”),
 }
}
fnprincipal() {
lăsa culoare = Curcubeu:: Albastru;
 print_color (culoare);
}

S-ar putea să primești variantele nu se construiesc niciodată sau avertismente similare când veți încerca să executați codul de mai sus, deoarece celelalte variante în afară de varianta Albastru nu au fost niciodată construite în acest cod. Astfel, în acest caz, puteți ignora în siguranță aceste avertismente, deoarece este intenționat.

The print_color funcția preia un parametru de culoare de tipul enumerare Rainbow. Declarația de potrivire se potrivește cu culoarea dintr-o suită de culori care sunt accesate prin numele variantelor. Și, în sfârșit, mesajul este imprimat pe baza culorii potrivite.

Puteți utiliza potrivirea modelului pentru operațiuni complexe, cum ar fi mai multe valori returnate bazate pe o condiție.

fncalculează_lungimea de undă(culoare: Curcubeu) -> u32 {
Meci culoare {
 Curcubeu:: Roșu => 700,
 Curcubeu:: Portocaliu => 590,
 Curcubeu:: Galben => 570,
 Curcubeu:: Verde => 510,
 Curcubeu:: Albastru => 475,
 Curcubeu:: Indigo => 445,
 Curcubeu:: Violet => 400,
 }
}

The calculează_lungimea de undă funcția preia o variantă de culoare a tipului de enumerare Rainbow ca parametru și returnează un număr întreg nesemnat de 32 de biți, care este lungimea de undă a culorii care se potrivește cu modelul.

Rust oferă, de asemenea, structuri pentru crearea de tipuri personalizate

Enumerările sunt utile pentru definirea tipurilor personalizate pentru mai multe operațiuni, mai ales în cazurile în care câmpurile sunt cunoscute și definite.

Rust oferă, de asemenea, structuri pe care le puteți utiliza pentru a crea tipuri personalizate cu câmpuri numite. Spre deosebire de enumerari, structurile vă permit să definiți câmpuri de diferite tipuri pe care le puteți accesa și modifica individual.