Ein CLI-Tool bekommt seine Aufträge über Argumente: mess-cli top 3. Mit Cargo übergibst du sie nach zwei Bindestrichen: cargo run -- top 3. Alles vor -- ist für Cargo, alles danach für dein Programm.

Die Standardbibliothek liefert sie über std::env::args(), einen Iterator über Strings. Element 0 ist der Programmname, deshalb überspringst du es. So sieht main im echten Programm aus:

fn main() {
    let echte: Vec<String> = std::env::args().skip(1).collect();
    let args: Vec<&str> = echte.iter().map(|s| s.as_str()).collect();
    match parse_args(&args) {
        Ok(auftrag) => println!("{}", ausfuehren(&auftrag)),
        Err(e) => eprintln!("Fehler: {e}"),
    }
}

Der wichtigste Teil ist die Prüfung in einer eigenen Funktion parse_args(args: &[&str]) -> Result<Auftrag, String>. Sie prüft Anzahl, Format und Wertebereich und liefert entweder einen fertigen Auftrag oder eine verständliche Fehlermeldung. Zwei Vorteile: main bleibt kurz, und du kannst parse_args mit erfundenen Argumenten testen, ohne das Programm zu starten. Genau das macht das Beispiel unten: Es füttert parse_args mit simulierten Argumentlisten. eprintln! schreibt übrigens nach stderr, den Kanal für Fehlermeldungen.

Sicherheit bei Argumenten:

Ursache: Argumente kommen vom Benutzer oder aus Skripten und können alles enthalten: Buchstaben statt Zahlen, 0, eine Million, leere Texte.
Erkennung: unwrap() auf parse() oder ein direkter Index wie args[1] sind Warnzeichen für eine mögliche Panic.
Test im Lab: Tests mit kaputten Eingaben: keine Argumente, drei, 0, 500, unbekannter Befehl.
Fix: parse_args mit Result, Wertebereich prüfen (zum Beispiel 1 bis 10).
Verifikation: Alle Fehlertests grün, das Programm endet bei falscher Eingabe mit Meldung statt Panic.
Betrieb: Keine Passwörter oder Tokens als Argument. Sie stehen in der Shell-History und in der Prozessliste (ps). Geheimnisse kommen aus einer Umgebungsvariablen oder einem Secrets-Manager.

Für größere Tools nimmst du die Crate clap (cargo add clap --features derive). Du beschreibst die Argumente als Struct, clap erzeugt Prüfung, Fehlermeldungen und --help:

use clap::Parser;

#[derive(Parser)]
#[command(about = "Messdateien von Elbwerk auswerten")]
struct Args {
    /// Wie viele Zähler im Ranking?
    #[arg(short, long, default_value_t = 3)]
    top: u32,
}

fn main() {
    let args = Args::parse();   // bei Fehlern: Meldung und Ende
    println!("Top {}", args.top);
}

Hinweis: std::env::args() bricht mit einer Panic ab, wenn ein Argument kein gültiges Unicode ist. Wer auch solche Eingaben annehmen muss, nimmt std::env::args_os().

Rust Lernpfad von den Grundlagen zur sicheren Systementwicklung.

Anmelden