CLI-Frameworks für Rust: Überblick über die besten Tools zur Erstellung von Kommandozeilen-Dienstprogrammen

CLI-Frameworks für Rust: Leistungsstarke Tools zur Erstellung von Konsolenanwendungen

Rust ist eine systemnahe Programmiersprache, die aufgrund ihrer Leistung, Sicherheit und modernen Möglichkeiten an Popularität gewinnt. Eine der häufigsten Anwendungen von Rust ist die Erstellung von Kommandozeilen-Dienstprogrammen (CLI). Von ripgrep über bat bis fd – viele bekannte Tools wurden in Rust geschrieben. In diesem Artikel betrachten wir die wichtigsten CLI-Frameworks für Rust, die Ihnen helfen, schnell und qualitativ hochwertig eigene Konsolenanwendungen zu entwickeln.

Warum Rust für CLI wählen?

Rust bietet mehrere entscheidende Vorteile für die CLI-Entwicklung:

• Leistung – kompilierter Code läuft mit minimalem Overhead.
• Speichersicherheit – das Ownership-System verhindert Speicherlecks und Datenrennen.
• Plattformunabhängigkeit – eine Codebasis funktioniert unter Windows, macOS und Linux.
• Ökosystem – eine reichhaltige Sammlung von Bibliotheken für Argument-Parsing, farbige Ausgabe, Konfigurationsverwaltung.

Wichtige CLI-Frameworks für Rust

1. Clap (Command Line Argument Parser)

Clap ist das beliebteste und funktionsreichste Framework zum Parsen von Kommandozeilenargumenten in Rust. Es unterstützt automatische Hilfegenerierung, Vorschläge, Validierung, Unterbefehle und vieles mehr.

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 bietet zwei Ansätze: deklarativ (über derive-Makros) und funktional (über die Builder-API). Für die meisten Projekte wird der derive-Ansatz empfohlen – er ist kürzer und lesbarer.

2. StructOpt

StructOpt ist ein Aufsatz auf Clap, der es ermöglicht, Argumente über Strukturen zu definieren. Ab Version 3.0 hat Clap die Funktionalität von StructOpt direkt integriert, weshalb StructOpt heute als veraltet gilt. Viele ältere Projekte verwenden es jedoch weiterhin.

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

Wichtig: Verwenden Sie für neue Projekte Clap mit derive-Makros – dies ist die moderne und unterstützte Alternative.

3. Argh

Argh ist ein leichtes und schnelles Framework, das sich auf Minimalismus konzentriert. Es benötigt keine zusätzlichen Abhängigkeiten (außer sich selbst) und kompiliert sehr schnell. Ideal für kleine Dienstprogramme.

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