Arguments de ligne de commande en Rust : guide complet pour débutants

Comment passer et traiter les arguments de ligne de commande en Rust ?

Quiconque a déjà écrit des utilitaires console en Python sait à quel point il est pratique de récupérer des paramètres via sys.argv. Mais lorsque vous passez à Rust — un langage de programmation système qui promet vitesse et sécurité — une question légitime se pose : "How can I access command line parameters in Rust?"

Cette question est l'une des plus populaires sur Stack Overflow (des dizaines de milliers de vues), et ce n'est pas sans raison. Rust propose non pas une, mais trois approches principales pour travailler avec les arguments de ligne de commande. De la plus simple std::env::args() aux puissantes bibliothèques comme clap et structopt. Dans cet article, nous allons analyser chacune d'elles avec des exemples pratiques, afin que vous puissiez choisir l'outil adapté à votre tâche.

Pourquoi est-ce important ?

La capacité à travailler avec les arguments de ligne de commande est une compétence de base pour tout développeur Rust. Sans elle, il est impossible de créer :

\n
• des utilitaires CLI (par exemple, un équivalent de grep, find ou votre propre script de déploiement) ;
\n
• des applications serveur avec configuration via des drapeaux de lancement ;
\n
• des outils d'automatisation et de DevOps.
\n

Commençons par la méthode la plus simple, puis passons progressivement aux solutions professionnelles.

Méthode 1 : std::env::args() — approche minimaliste

La façon la plus simple d'obtenir les arguments de ligne de commande en Rust est d'utiliser la fonction standard std::env::args(). Elle retourne un itérateur de chaînes de caractères, où le premier élément est le chemin vers le fichier exécutable, et les autres sont les paramètres passés.

use std::env;\n\nfn main() {\n    let args: Vec<String> = env::args().collect();\n    \n    // Le premier argument est toujours le nom du programme\n    println!("Chemin du programme : {}", args[0]);\n    \n    // Les autres sont les arguments utilisateur\n    if args.len() > 1 {\n        println!("Arguments passés :");\n        for (i, arg) in args[1..].iter().enumerate() {\n            println!("  Argument {} : {}", i + 1, arg);\n        }\n    } else {\n        println!("Aucun argument passé.");\n    }\n}

Lançons notre programme :

$ cargo run -- hello world 42\nChemin du programme : ./target/debug/myapp\nArguments passés :\n  Argument 1 : hello\n  Argument 2 : world\n  Argument 3 : 42

Avantages : code minimal, aucune dépendance, contrôle total.

Inconvénients : traitement manuel des drapeaux (par exemple, --name ou -v), absence de vérification de type (tous les arguments sont des chaînes), pas d'aide intégrée --help.

Cette méthode est parfaite pour des esquisses rapides ou lorsque vous avez exactement un argument obligatoire. Mais pour des projets sérieux, il vaut mieux envisager des alternatives.

Variante avec env::args_os()

Si vous avez besoin des octets bruts (par exemple, pour travailler avec des noms de fichiers non UTF-8), utilisez std::env::args_os(). Elle retourne OsString au lieu de String :

use std::env;\nuse std::ffi::OsString;\n\nfn main() {\n    let args: Vec<OsString> = env::args_os().collect();\n    println!("Premier argument (OsString) : {:?}", args[0]);\n}

Méthode 2 : La crate clap — parsing déclaratif

Lorsque le projet grandit, le parsing manuel des arguments devient une source de bugs. C'est là qu'intervient clap — la crate la plus populaire pour travailler avec la ligne de commande dans l'écosystème Rust. Elle permet de décrire de manière déclarative tous les paramètres, drapeaux et sous-commandes.

Ajoutez dans Cargo.toml :

[dependencies]\nclap = { version = "4.5", features = ["derive"] }

Voici maintenant un exemple utilisant les macros derive (méthode recommandée) :

use clap::Parser;\n\n/// Programme simple pour démontrer clap\n#[derive(