Comment utiliser les énumérations à la rouille

Dans cet article, nous explorerons comment travailler avec Enum in the Rust Programming Language.

Définir une énumération

Considérons un exemple où nous pouvons utiliser un type d'énumération. Par exemple, si nous devons stocker les directions, nous pouvons utiliser une enum. En règle générale, nous pouvons exprimer la direction dans quatre valeurs majeures possibles: nord-est, sud et ouest.

Si nous considérons la direction, un véhicule peut soit se déplacer dans l'une de toutes les directions possibles mais pas plus une fois en même temps.

Cela rend une énumération fortement appropriée pour une telle structure.

Pour déclarer une énumération de rouille, nous commençons par l'énumération du mot-clé, suivie de l'identifiant de l'énumération. Un exemple est fourni ci-dessous:

Direction de l'énumération
Nord,
Est,
Sud,
Ouest

L'exemple précédent nous permet de définir un type de type de type de type personnalisé que nous pouvons réutiliser dans le programme.

Vous pouvez également définir une énumération avec une variante sans données qui y sont associées, similaires à une structure de type unité. Une énumération peut également avoir des variantes avec des données nommées et des données sans nom.

Un exemple est comme indiqué:

Enum Person
Vivant,
Mâle (corde, f64),
Femme nom: chaîne, âge: i32

Les énumérations sont utiles lors de la création d'un type comme indiqué dans l'exemple précédent. Si nous devions utiliser la définition de structure, nous devions créer plusieurs structures. Les énumérations nous permettent de stocker toutes les variantes sous une seule entité.

Valeurs d'énumération

Après avoir déclaré une énumération, nous pouvons créer une instance d'une énumération en utilisant les variantes possibles disponibles dans le type.

Par exemple:

fn main ()
Soit N = Direction :: North;
Soit E = Direction :: East;
Soit S = Direction :: Sud;
Laissez W = Direction :: Ouest;

Pour accéder à la variante d'une énumération, nous utilisons le double côlon pour séparer l'espace de nom de la variante et son identifiant.

Faire correspondre les énumérations

Une utilisation majeure des énuméraires est la correspondance des modèles. Si vous avez plusieurs correspondances potentielles dans votre programme, l'option pour un bloc IF-Else peut ne pas créer de code lisible. Pour un tel scénario, nous pouvons utiliser des énumérations avec l'opérateur de match.

L'opérateur de correspondance nous permet de comparer une valeur avec une liste de modèles, tels que des noms de variables, des valeurs littérales et des variantes d'énumération.

Considérez l'exemple suivant de l'énumération des directions que nous avons créée plus tôt:

fn main ()
Laissez la direction: direction = direction :: nord;
faire correspondre la direction
Direction :: North =>
println!("La direction est nord");
,
Direction :: East =>
println!("La direction est à l'est");
,
Direction :: Sud =>
println!("La direction est au sud");
,
Direction :: West =>
println!("La direction est ouest");

Dans l'exemple précédent, nous commençons par le mot-clé de correspondance suivi de l'expression que nous souhaitons évaluer. Bien que la syntaxe puisse sembler similaire à une instruction IF, l'expression de correspondance ne renvoie pas un vrai vrai ou un faux booléen. Le type de retour peut être de n'importe quel type. Dans notre cas, le type de retour est une énumération de direction.

Le bloc suivant est connu comme un bras de match. Un bras contient le modèle à correspondre et le bloc de code à exécuter si le match est trouvé.

Dans notre exemple, le premier bras contient le modèle de direction :: North et l'opérateur =>. Cela ouvre le bloc pour que le code s'exécute lorsque le match est trouvé. Pour l'exemple précédent, nous imprimons le message pour la direction correspondante.

Le compilateur évaluera l'expression de la correspondance et comparera pour un motif de correspondance dans les bras fournis. Si une correspondance est trouvée dans un bras spécifique, le code dans le bloc de bras est exécuté. Sinon, le compilateur continue avec l'évaluation.

Nous pouvons exécuter le code précédent comme suit:

Rustc Enum.Rs
./ Enum

Le code précédent doit revenir comme suit:

$ ./ Enum
La direction est vers le nord

L'espace _

Supposons que nous voulons seulement remplir des fonctions spécifiques pour des modèles particuliers dans une enum. Ensuite, faites une action commune pour tous les autres.

Pour un tel cas, nous pouvons utiliser l'opérateur _, qui correspond à tous les autres cas non spécifiés dans une expression de correspondance.

Prenons l'énumération des instructions que nous avons créée plus tôt. Nous pouvons définir une action si la direction est vers le nord, et sinon, nous exécutons un message global pour tous les autres cas. Le code résultant est comme indiqué ci-dessous:

fn main ()
Laissez la direction: direction = direction :: nord;
faire correspondre la direction
Direction :: North =>
println!(«La direction est vers le nord»);
,
_ =>
println!(«Autre direction»)

Si nous modifions la valeur de la «direction», nous devons obtenir la sortie suivante comme:

Laissez la direction: direction = direction :: Est;
$ cargo Run
Autre direction

Le code à l'intérieur du bloc _ est exécuté car nous n'avons défini aucun cas correspondant pour la direction est.

Zéro variant enums

Nous pouvons également créer une énumération sans variantes. Ceux-ci sont connus sous le nom d'énumérations zéro variant, et nous ne pouvons pas les instanciation.

Un exemple d'énumérage zéro variant est fourni ci-dessous:

enum zéroenum

Nous ne pouvons pas jeter zéro variant enums à d'autres types.

Conclusion

Dans cet article, nous avons exploré les bases de travailler avec des types d'énumération dans le langage de programmation de la rouille. Nous avons mis en évidence comment travailler avec Enum in Rust, qui comprend la définition d'un énumération, l'utilisation des valeurs d'énumération et comment correspondre aux énumérations. Nous espérons que vous avez trouvé cet article utile. Vérifiez les autres articles sur les indices Linux pour plus de conseils et d'informations.