Frameworks CLI pour Rust : aperçu des meilleurs outils pour créer des utilitaires en ligne de commande

Frameworks CLI pour Rust : des outils puissants pour créer des applications console

Rust est un langage de programmation système qui gagne en popularité grâce à ses performances, sa sécurité et ses fonctionnalités modernes. L'une des utilisations les plus courantes de Rust est la création d'utilitaires en ligne de commande (CLI). De ripgrep à bat et fd, de nombreux outils célèbres sont écrits en Rust. Dans cet article, nous allons passer en revue les principaux frameworks CLI pour Rust qui vous aideront à développer rapidement et efficacement vos propres applications console.

Pourquoi choisir Rust pour la CLI ?

Rust offre plusieurs avantages clés pour le développement de CLI :

• Performance — le code compilé fonctionne avec une surcharge minimale.
• Sécurité mémoire — le système de possession (ownership) prévient les fuites et les courses de données.
• Multiplateforme — une seule base de code fonctionne sur Windows, macOS et Linux.
• Écosystème — un riche ensemble de bibliothèques pour l'analyse d'arguments, la sortie colorée, la gestion des configurations.

Principaux frameworks CLI pour Rust

1. Clap (Command Line Argument Parser)

Clap est le framework le plus populaire et le plus fonctionnel pour l'analyse des arguments en ligne de commande en Rust. Il prend en charge la génération automatique d'aide, les suggestions, la validation, les sous-commandes et bien plus encore.

use clap::{Parser, Subcommand};

#[derive(Parser)]#[command(name = "git")]#[command(about = "A fictional version of git", long_about = None)]struct Cli {    #[command(subcommand)]    command: Commands,}

#[derive(Subcommand)]enum Commands {    /// Clone a repository    Clone {        /// URL of the repository        url: String,    },    /// Push changes    Push {        /// Remote name        remote: String,        /// Branch name        branch: String,    },}

fn main() {    let cli = Cli::parse();    match &cli.command {        Commands::Clone { url } => println!("Cloning from {}", url),        Commands::Push { remote, branch } => println!("Pushing to {} branch {}", remote, branch),    }}

Clap propose deux approches : déclarative (via les macros derive) et fonctionnelle (via l'API Builder). Pour la plupart des projets, il est recommandé d'utiliser l'approche derive — elle est plus courte et plus lisible.

2. StructOpt

StructOpt est une surcouche de Clap qui permet de définir les arguments via des structures. Depuis la version 3.0, Clap a intégré directement les fonctionnalités de StructOpt, ce qui rend StructOpt désormais obsolète. Cependant, de nombreux anciens projets l'utilisent encore.

use structopt::StructOpt;

#[derive(StructOpt)]struct Cli {    #[structopt(short = 'n', long = "name")]    name: String,    #[structopt(short = 'c', long = "count", default_value = "1")]    count: u32,}

fn main() {    let args = Cli::from_args();    for _ in 0..args.count {        println!("Hello, {}!", args.name);    }}

Important : pour les nouveaux projets, utilisez Clap avec les macros derive — c'est l'alternative moderne et maintenue.

3. Argh

Argh est un framework léger et rapide qui se concentre sur le minimalisme. Il ne nécessite aucune dépendance supplémentaire (à part lui-même) et se compile très rapidement. Idéal pour les petits utilitaires.

use argh::FromArgs;

#[derive(FromArgs)]/// A simple greeting toolstruct Greeting {    /// name to greet    #[argh(option, short = 'n')]    name: String,

    /// number of times to greet    #[argh(option, short = 'c', default = "1")]    count: u32,}

fn main() {    let greeting: Greeting = argh::from_env();    for _ in 0..greeting.count {        println!("Hello, {}!", greet