Arguments de ligne de commande Rust

Les arguments en ligne de commande se réfèrent à un ensemble de valeurs ou de spécificateurs qui sont transmis au nom d'un programme terminal. Ces arguments peuvent donc modifier le comportement du programme tel que défini dans le code source.

Par exemple, vous pouvez passer le répertoire que vous souhaitez énumérer à la commande LS. Par conséquent, le chemin vers le répertoire est connu comme l'argument de la commande LS.

Cet article passera en revue les principes fondamentaux de l'acceptation et de l'analyse des arguments de ligne de commande dans le langage de programmation Rust à l'aide du module Env de la bibliothèque standard.

Configuration et importations

La première étape consiste à créer un répertoire pour stocker notre code source. Pour plus de simplicité, générons un ensemble de rouille en utilisant la cargaison comme:

$ cargo new Rust_arguments

Renommez votre projet à n'importe quel nom que vous voyez.

Ensuite, naviguez dans le répertoire source et ouvrez le principal.Fichier RS ​​avec votre éditeur de texte préféré.

$ CD RUST_ARGUMENTS / SRC && vim Main.Rs

La deuxième étape consiste à importer les modules requis. Nous utiliserons le module Env de la bibliothèque standard pour analyser les arguments en ligne de commande pour cet article.

Le module Env offre une fonction pour travailler avec des variables d'environnement, des arguments, etc. Pour l'utiliser, importez-le en utilisant AS:

Utilisez Std :: Env;

Vecteur d'argument

À l'intérieur de la fonction principale, nous devons créer un vecteur de chaînes qui contiendront les arguments que nous transmettrons au programme.

Nous pouvons le faire en ajoutant la ligne suivante:

Laissez les args: vec = env :: args ().collecter();

Le code ci-dessus utilise la méthode Collect pour itérer sur l'argument transmis aux arguments et les ajouter au vecteur. Le vecteur est de type chaînes annoté par le VEC dans notre cas. C'est parce que la rouille ne peut pas déduire le type de collection de vecteur.

Arguments imprimés

Maintenant que nous pouvons accepter les arguments de commande et les stocker dans un vecteur, essayons de les imprimer. Nous pouvons le faire avec la fonction ITER, comme indiqué ci-dessous:

Utilisez Std :: Env;
fn main ()
Laissez les args: vec = env :: args ().collecter();
pour arg dans args.iter ()
println!("", arg);

La fonction iter itérara sur chaque argument transmis au programme et l'imprimera. Si nous exécutons le code ci-dessus, nous devrions voir une sortie comme:

Le programme renvoie le nom de l'exécutable. Rust traitera le nom de l'exécutable comme le premier argument. Par conséquent, l'argument à l'index 0 dans le vecteur d'argument est le chemin d'accès au nom du programme.

Ceci est une caractéristique commune dans d'autres langages de programmation, notamment C, Python, GO, etc.

Si nous fournissons d'autres arguments après le nom du programme, Rust les ajoutera à l'index 1, 2, 3… au vecteur d'argument.

Par exemple:

cargo run argument1 argument2 argument3… argumentn

Notez que l'exemple ci-dessus transmet 5 arguments au programme. Le résultat est comme indiqué:

Target \ Debug \ Rust_cmd_args.exe
argument1
argument2
argument3
…
argument

Comme vous pouvez le voir, le programme imprime tous les arguments passés.

Accéder et enregistrer les arguments

Jusqu'à présent, nous n'avons imprimé que les arguments du programme. Bien que cela illustre comment fonctionnent les vecteurs d'arguments, il ne fait pas vraiment beaucoup.

Nous pouvons accéder et enregistrer chaque argument sur une variable pour développer notre programme.

Pour accéder à un argument, nous pouvons utiliser l'index comme:

Utilisez Std :: Env;
fn main ()
Laissez les args: vec = env :: args ().collecter();
println!("", args [1]);

Dans l'exemple ci-dessus, nous accédons au premier argument en utilisant l'index 1. Le résultat est comme indiqué:

Cargo Run Salut!

Nous pouvons enregistrer l'argument dans une variable comme:

Utilisez Std :: Env;
fn main ()
Laissez les args: vec = env :: args ().collecter();
Soit Greller = & Args [1];
si salut == "hi"
println!("Rebonjour!");
autre
println!("Nous acceptons uniquement les salutations!")

Dans le programme ci-dessus, nous acceptons de sauver le premier argument et de l'enregistrer dans une variable. Nous utilisons ensuite sa valeur dans un bloc if… else pour effectuer une action.

Nous pouvons exécuter le code ci-dessus comme:

$ cargo run salut

Le programme doit retourner «salut en retour!" comme:

Si nous passons un autre argument qui n'équivaut pas «Hi», nous avons exécuté le bloc Else:

$ cargo coure bye

Conclusion

Fantastique! Nous avons un programme qui peut accepter, analyser, sauver et argumenter avec cela. Continuez à pratiquer pour en savoir plus.