Énumérations et correspondance de modèles dans Rust

Rust fournit divers types de données pour effectuer des opérations, à partir de types de données de base tels que des chaînes, des entiers et des flottants. des nombres de points aux types de données composés comme les vecteurs et les tableaux aux types de données composés comme les structures et les énumérations.

Les énumérations (é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 pour une variable sont limitées et connues.

Définir les énumérations dans Rust

Déclarer des énumérations dans Rust est similaire à déclarer des énumérations en C#. Vous utiliserez le énumération mot-clé suivant le nom et un ensemble 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 :

énumérationJour de la semaine {
 Lundi,
 Mardi,
 Mercredi,
 Jeudi,
 Vendredi,
 Samedi,
 Dimanche,
}

Le Jour de la semaine enum représente les jours de la semaine. Le variantes sont les noms du jour et n'ont pas de valeurs associées. De plus, les variantes de votre énumération peuvent être n'importe lesquelles Type de données de rouille.

Vous pouvez accéder aux variantes en spécifiant le nom de la variante à l'aide de l'opérateur de séparateur de chemin (::) sur l'énumération.

laisser jour = Jour de la semaine:: Lundi ;
// version typée statiquement de la variable `day`
laisser jour: Jour de la semaine = Jour de la semaine:: Lundi ;

Le code précise que vous souhaitez accéder au Lundi variante de l'énumération Weekday.

Variantes et discriminants des énumérations

Les variantes d'une énumération sont associées à des valeurs entières appelées discriminant. Par défaut, les valeurs discriminantes commencent à zéro et sont incrémentées de 1 pour les variantes suivantes; cependant, il est possible de spécifier des valeurs discriminantes personnalisées pour chaque variante.

Voici un exemple de l'énumération Weekday avec des variantes à valeur assignée.

énumérationJour de la semaine {
 Lundi = 1,
 mardi = 2,
 mercredi = 3,
 jeudi = 4,
 vendredi = 5,
 samedi = 6,
 dimanche = 7,
}

L'énumération Weekday a sept variantes représentant chaque jour de la semaine, et chaque jour a une valeur (appelée le discriminant) qui leur est attribuée. Les variantes sont dans l'ordre du premier au dernier jour de la semaine.

Vous pouvez accéder à la valeur discriminante à l'aide du nom de la variante.

fnprincipal() {
imprimez !("Lundi: {}", Jour de la semaine:: Lundi commei32);
imprimez !("Mardi: {}", Jour de la semaine:: Mardi commei32);
imprimez !("Mercredi: {}", Jour de la semaine:: Mercredi commei32);
imprimez !("Jeudi: {}", Jour de la semaine:: Jeudi commei32);
imprimez !("Vendredi: {}", Jour de la semaine:: Vendredi commei32);
imprimez !("Samedi: {}", Jour de la semaine:: Samedi commei32);
imprimez !("Dimanche: {}", Jour de la semaine:: Dimanche commei32);
}

Le imprimez ! macro est utilisée pour imprimer les discriminants. Chaque impression! l'appel de macro prend deux arguments: une chaîne de format et une valeur. La chaîne de format spécifie comment formater la sortie; la valeur est la valeur réelle qui est imprimée.

Dans ce cas, la chaîne de format est un littéral de chaîne qui contient le nom du jour de la semaine et la valeur est la variante enum avec une conversion explicite en i32 type entier.

La conversion explicite en i32 est nécessaire car les énumérations Rust sont représentées sous forme d'entiers, mais le type d'entier spécifique dépend de la taille de l'énumération. Par défaut, Rust attribue le plus petit type entier pouvant représenter tous les discriminants de l'énumération. Mais dans ce cas, vous souhaitez imprimer les valeurs sous forme d'entiers i32, vous devez donc les convertir explicitement.

Voici le résultat de l'exécution du principal fonction:

Correspondance de motifs dans Rust

La correspondance de modèles est une construction de structure de contrôle Rust utile pour identifier les modèles de données. La correspondance de modèles permet d'écrire un code concis et efficace tout en fonctionnant avec structures de données avancées ou effectuer des opérations complexes.

Vous utiliserez le correspondre mot-clé suivi du => séparateur pour le motif et l'opération pour le motif, respectivement. Le modèle peut être n'importe quelle expression Rust, y compris des littéraux, des variables et des appels de fonction.

Voici un exemple d'instruction de correspondance :

fnprincipal(){
laisser x = 5;
correspondre X {
1 => imprimez !("un"),
2 => imprimez !("deux"),
3 => imprimez !("trois"),
// s'exécute si aucun des motifs ne correspond
 _ => imprimez !("autre chose"),
 }
}

Le principal la fonction correspond X contre plusieurs motifs, puis imprime la valeur en fonction de la valeur de x. Le modèle de trait de soulignement (_) est un modèle de caractère générique utilisé comme fourre-tout pour les cas qui ne sont pas explicitement gérés.

Énumérations et correspondance de modèles

Les énumérations et la correspondance de modèles sont utiles pour exprimer et travailler avec des structures de données avancées de manière sûre et efficace. Vous pouvez utiliser des énumérations pour définir un ensemble fixe de valeurs et une correspondance de modèle pour travailler avec ces valeurs.

Voici une énumération pour les couleurs d'un arc-en-ciel :

énumérationArc-en-ciel {
 Rouge,
 Orange,
 Jaune,
 Vert,
 Bleu,
 Indigo,
 Violet,
}

Chaque variante du Arc-en-ciel enum représente une couleur de l'arc-en-ciel. Vous pouvez utiliser la correspondance de modèle avec l'instruction match pour faire correspondre les modèles à 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 basé sur la couleur.

fnprint_color(couleur: arc-en-ciel) {
correspondre couleur {
 Arc-en-ciel:: Rouge => imprimez !("La couleur est rouge !"),
 Arc-en-ciel:: Orange => imprimez !("La couleur est orange !"),
 Arc-en-ciel:: Jaune => imprimez !("La couleur est jaune !"),
 Arc-en-ciel:: Vert => imprimez !("La couleur est verte !"),
 Arc-en-ciel:: Bleu => imprimez !("La couleur est bleue !"),
 Arc-en-ciel:: Indigo => imprimez !("La couleur est indigo !"),
 Arc-en-ciel:: Violet => imprimez !("La couleur est violette !"),
 }
}
fnprincipal() {
laisser couleur = arc-en-ciel:: bleu ;
 print_color (couleur);
}

Vous pouvez obtenir les variantes ne sont jamais construites ou des avertissements similaires lorsque vous essayez d'exécuter le code ci-dessus car les autres variantes à l'exception de la variante bleue n'ont jamais été construites dans ce code. Ainsi, dans ce cas, vous pouvez ignorer ces avertissements en toute sécurité car c'est intentionnel.

Le print_color La fonction prend un paramètre de couleur de type Rainbow enum. L'instruction de correspondance correspond à la couleur d'une suite de couleurs accessibles via les noms de variantes. Et enfin, le message est imprimé en fonction de la couleur assortie.

Vous pouvez utiliser la correspondance de modèles pour des opérations complexes telles que plusieurs valeurs de retour basées sur une condition.

fncalculer_la longueur d'onde(couleur: arc-en-ciel) -> u32 {
correspondre couleur {
 Arc-en-ciel:: Rouge => 700,
 Arc-en-ciel:: Orange => 590,
 Arc-en-ciel:: Jaune => 570,
 Arc-en-ciel:: Vert => 510,
 Arc-en-ciel:: Bleu => 475,
 Arc-en-ciel:: Indigo => 445,
 Arc-en-ciel:: Violet => 400,
 }
}

Le calculer_la longueur d'onde La fonction prend une variante de couleur du type Rainbow enum comme paramètre et renvoie un entier 32 bits non signé qui correspond à la longueur d'onde de la couleur qui correspond au motif.

Rust fournit également des structures pour créer des types personnalisés

Les énumérations 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 structures que vous pouvez utiliser pour créer des types personnalisés avec des champs nommés. Contrairement aux énumérations, les structures vous permettent de définir des champs de différents types auxquels vous pouvez accéder et modifier individuellement.