Rust fournit différents types de données pour effectuer des opérations, depuis les types de données de base comme les chaînes de caractères, les entiers et les nombres à virgule flottante jusqu’aux types de données composées comme les vecteurs et les tableaux, en passant par les types de données composées comme les structs et les énumérations.
Les énumérations sont un type de données qui permet la représentation d’un ensemble fixe de valeurs, comme les jours de la semaine et la couleur de l’arc-en-ciel. Les énumérations sont pratiques lorsque les valeurs possibles d’une variable sont limitées et connues.
Définition des Enums en Rust
La déclaration des enums en Rust est similaire à celle des enums en C#. Vous utiliserez l’élément enum qui suit le nom et une série d’accolades pour définir les énumérations. Vous pouvez définir les variantes possibles (entités) à l’intérieur des accolades avec une virgule comme séparateur.
Voici une énumération pour les jours de la semaine :
enum Weekday {
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday,
}
Le Jour de la semaine L’enum représente les jours de la semaine. L’enum variantes sont les noms du jour et n’ont pas de valeurs associées. En outre, les variantes de votre énumération peuvent être n’importe quel type de données Rust.
Vous pouvez accéder aux variantes en spécifiant le nom de la variante à l’aide du séparateur de chemin (: 🙂 sur l’énumération.
let day = Weekday::Monday;
// statically typed version of the `day` variable
let day: Weekday = Weekday::Monday;
Le code spécifie que vous voulez accéder à la Lundi variante de l’énumération des jours de la semaine.
Variantes et discriminants des Enums
Les variantes d’une énumération sont associées à des valeurs entières appelées discriminant. Par défaut, les valeurs du discriminant commencent à zéro et sont incrémentées de 1 pour les variantes suivantes ; il est toutefois possible de spécifier des valeurs de discriminant personnalisées pour chaque variante.
Voici un exemple de l’enum Weekday avec des variantes à valeur attribuée.
enum Weekday {
Monday = 1,
Tuesday = 2,
Wednesday = 3,
Thursday = 4,
Friday = 5,
Saturday = 6,
Sunday = 7,
}
L’énumération des jours de la semaine comporte sept variantes représentant chaque jour de la semaine, et une valeur (appelée discriminant) est attribuée à chaque jour. Les variantes sont classées dans l’ordre du premier au dernier jour de la semaine.
Vous pouvez accéder à la valeur du discriminant en utilisant le nom de la variante.
fn main() {
println!("Monday: {}", Weekday::Monday as i32);
println!("Tuesday: {}", Weekday::Tuesday as i32);
println!("Wednesday: {}", Weekday::Wednesday as i32);
println!("Thursday: {}", Weekday::Thursday as i32);
println!("Friday: {}", Weekday::Friday as i32);
println!("Saturday: {}", Weekday::Saturday as i32);
println!("Sunday: {}", Weekday::Sunday as i32);
}
Le println ! est utilisée pour imprimer les discriminants. Chaque invocation de la macro println ! prend deux arguments : une chaîne de format et une valeur. La chaîne de formatage indique comment formater la sortie ; la valeur est la valeur réelle qui sera imprimée.
Dans ce cas, la chaîne de format est une chaîne littérale qui contient le nom du jour de la semaine, et la valeur est la variante de l’énumération avec un cast explicite vers l’élément i32 type d’entier.
Le cast explicite vers i32 est nécessaire car les enums Rust sont représentés comme des entiers, mais le type d’entier spécifique dépend de la taille de l’enum. Par défaut, Rust assigne le plus petit type d’entier qui peut représenter tous les discriminants de l’énumération. Mais dans ce cas, vous voulez imprimer les valeurs en tant qu’entiers i32, vous devez donc les convertir explicitement.
Voici le résultat de l’exécution de la commande principal fonction :
Correspondance de motifs en Rust
La correspondance de motifs est une construction de structure de contrôle Rust utile pour identifier des motifs de données. La correspondance de motifs permet d’écrire un code concis et efficace tout en utilisant des structures de données avancées ou en effectuant des opérations complexes.
Vous utiliserez la fonction match suivi du mot-clé => ; pour le motif et l’opération pour le motif, respectivement. Le motif peut être n’importe quelle expression Rust, y compris les littéraux, les variables et les appels de fonction.
Voici un exemple de déclaration de correspondance :
fn main(){
let x = 5;
match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
// runs if none of the patterns match
_ => println!("something else"),
}
}
Le principal correspondance des fonctions x en fonction de plusieurs motifs, puis imprime la valeur basée sur la valeur de x. Le motif de soulignement (_) est un motif de remplacement utilisé comme fourre-tout pour les cas qui ne sont pas explicitement traités.
Enums et correspondance de motifs
Les enums et le filtrage sont utiles pour exprimer et travailler avec des structures de données avancées d’une manière efficace et sans risque pour les types. Vous pouvez utiliser les enums pour définir un ensemble fixe de valeurs et le filtrage pour travailler avec ces valeurs.
Voici une énumération des couleurs d’un arc-en-ciel :
enum Rainbow {
Red,
Orange,
Yellow,
Green,
Blue,
Indigo,
Violet,
}
Chaque variante de l’enum Arc-en-ciel représente une couleur de l’arc-en-ciel. Vous pouvez utiliser la correspondance de motifs avec l’instruction match pour faire correspondre des motifs à la variante afin de contrôler le flux du programme en fonction de la couleur de l’arc-en-ciel.
Voici une fonction qui prend la variante de couleur de l’énumération Rainbow et imprime un message en fonction de la couleur.
fn print_color(color: Rainbow) {
match color {
Rainbow::Red => println!("The color is red!"),
Rainbow::Orange => println!("The color is orange!"),
Rainbow::Yellow => println!("The color is yellow!"),
Rainbow::Green => println!("The color is green!"),
Rainbow::Blue => println!("The color is blue!"),
Rainbow::Indigo => println!("The color is indigo!"),
Rainbow::Violet => println!("The color is violet!"),
}
}
fn main() {
let color = Rainbow::Blue;
print_color(color);
} 
Vous pouvez obtenir les variantes ne sont jamais construites ou des avertissements similaires lorsque vous essayez d’exécuter le code ci-dessus parce que les autres variantes en dehors de la variante bleue n’ont jamais été construites dans ce code. Dans ce cas, vous pouvez donc ignorer ces avertissements car ils sont intentionnels.
Le print_color La fonction print_color prend en compte un paramètre de couleur du type Rainbow enum. L’instruction match fait correspondre la couleur à une série de couleurs accessibles via les noms de variantes. Enfin, le message est imprimé en fonction de la couleur trouvée.
Vous pouvez utiliser la correspondance de motifs pour des opérations complexes telles que des valeurs de retour multiples basées sur une condition.
fn calculate_wavelength(color: Rainbow) -> u32 {
match color {
Rainbow::Red => 700,
Rainbow::Orange => 590,
Rainbow::Yellow => 570,
Rainbow::Green => 510,
Rainbow::Blue => 475,
Rainbow::Indigo => 445,
Rainbow::Violet => 400,
}
}
La fonction calculer_longueur d’onde prend en paramètre une variante de couleur du type Rainbow enum et renvoie un entier 32 bits non signé correspondant à la longueur d’onde de la couleur correspondant au motif.
Rust fournit également des structures pour créer des types personnalisés
Les Enums sont pratiques pour définir des types personnalisés pour plusieurs opérations, en particulier dans les cas où les champs sont connus et définis.
Rust fournit également des structs que vous pouvez utiliser pour créer des types personnalisés avec des champs nommés. Contrairement aux enums, les structs vous permettent de définir des champs de différents types auxquels vous pouvez accéder et que vous pouvez modifier individuellement.
