Comment utiliser les déclarations de correspondance dans la rouille

Une construction classique est prise en charge par la plupart. Bien qu'il prenne quelques syntaxes et une mise en forme différente, il nous permet de faire correspondre un cas ou une condition spécifique et de prendre l'action requise dans diverses langues.

Dans Rust, le mot clé Match implémente la syntaxe du cas de commutateur. Explorons comment utiliser la déclaration de match dans Rust.

Déclaration de match dans Rust

Nous allons commencer par la correspondance des mots clés, puis comparer la variable pour utiliser la construction de match. Nous ouvrons ensuite le corps de match, qui prend le cas comme une valeur «appariée» à la valeur de la variable spécifiée.

La syntaxe est comme indiqué ci-dessous:

correspondre à la variable
valeur => // faire ceci
valeur2 => // faire ceci

Considérez l'exemple ci-dessous qui correspond à un seul cas:

fn main ()
Soit l'âge = 18;
faire correspondre l'âge
18 => println!("Salut!"),
_ => println!("Inaccessible")

Dans l'exemple précédent, nous commençons par initialiser l'âge variable. Ensuite, nous utilisons l'instruction Match pour vérifier si l'âge est égal à 18; Si c'est vrai, nous imprimons «salut». Si la valeur de la variable ne correspond pas à 18, nous imprimons «inaccessibles».

Le soulignement, dans ce cas, montre la poignée d'autres cas non définis.

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

Pour correspondre à plusieurs valeurs, vous pouvez utiliser l'opérateur de tuyau, comme indiqué dans l'exemple ci-dessous:

fn main ()
Soit l'âge = 18;
faire correspondre l'âge
18 | 19 | 20 | 21 | 22 => println!("Salut!"),
_ => println!("Inaccessible")

Cela devrait vérifier si la valeur de la variable est égale à 18,19,20, 21 ou 22. Si c'est vrai, il exécute le bloc spécifié.

Pour correspondre à une plage de valeurs, vous pouvez utiliser l'opérateur de plage comme indiqué ci-dessous:

fn main ()
Soit l'âge = 18;
faire correspondre l'âge
18… = 22 => println!("Salut!"),
_ => println!("Inaccessible")

L'exemple précédent doit correspondre aux valeurs entre 18 et 22, inclusives.

Gardez à l'esprit que l'opérateur de match n'est pas limité aux types entiers. Vous pouvez faire correspondre les valeurs de chaîne ou les types booléens comme indiqué dans l'exemple ci-dessous:

fn main ()
Soit Boolean = true;
Laissez active = Match booléen
Faux => 0,
true => 1,
;
println!("Actif: ", actif)

L'exemple précédent utilise un type booléen pour vérifier les étuis correspondants. Notez que nous attribuons une valeur au lieu d'imprimer une valeur à la console.

Pour correspondre à une chaîne, nous pouvons effectuer ce qui suit:

fn main ()
Soit String = "Hi";
correspond à String
"Salut" => println!("Rebonjour!"),
"Bonjour" => println!("Non!"),
_ => println!("Salutation inconnue!")
;

Le code précédent doit imprimer:

Conclusion

Ce tutoriel couvre l'instruction Match dans Rust et comment nous pouvons l'utiliser pour comparer différents cas. De plus, nous avons discuté de la façon dont le mot clé Match met en œuvre la syntaxe du cas de commutateur et avons fourni des exemples. 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.