Frameworks CLI para Rust: revisión de las mejores herramientas para crear utilidades de línea de comandos

Frameworks CLI para Rust: herramientas potentes para crear aplicaciones de consola

Rust es un lenguaje de programación de sistemas que está ganando popularidad gracias a su rendimiento, seguridad y capacidades modernas. Una de las aplicaciones más comunes de Rust es la creación de utilidades de línea de comandos (CLI). Desde ripgrep hasta bat y fd, muchas herramientas conocidas están escritas en Rust. En este artículo, exploraremos los principales frameworks CLI para Rust que te ayudarán a desarrollar tus propias aplicaciones de consola de forma rápida y eficiente.

¿Por qué elegir Rust para CLI?

Rust ofrece varias ventajas clave para el desarrollo de CLI:

• Rendimiento — el código compilado funciona con una sobrecarga mínima.
• Seguridad de memoria — el sistema de ownership (propiedad) previene fugas y condiciones de carrera de datos.
• Multiplataforma — una sola base de código funciona en Windows, macOS y Linux.
• Ecosistema — un rico conjunto de bibliotecas para análisis de argumentos, salida con colores, trabajo con configuraciones.

Principales frameworks CLI para Rust

1. Clap (Command Line Argument Parser)

Clap es el framework más popular y funcional para analizar argumentos de línea de comandos en Rust. Soporta generación automática de ayuda, sugerencias, validación, subcomandos y mucho más.

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 proporciona dos enfoques: declarativo (a través de derive-macros) y funcional (a través de Builder API). Para la mayoría de los proyectos se recomienda usar el enfoque derive — es más corto y legible.

2. StructOpt

StructOpt es una capa sobre Clap que permite definir argumentos a través de estructuras. A partir de la versión 3.0, Clap incorporó la funcionalidad de StructOpt directamente, por lo que ahora StructOpt se considera obsoleto. Sin embargo, muchos proyectos antiguos todavía lo utilizan.

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);    }}

Importante: para proyectos nuevos, usa Clap con derive-macros — es la alternativa moderna y con soporte activo.

3. Argh

Argh es un framework ligero y rápido que se centra en el minimalismo. No requiere dependencias adicionales (excepto él mismo) y se compila muy rápidamente. Es ideal para utilidades pequeñas.

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