Learn Rust Coding · Lektion

clap-Grundlagen

Argumente parsen

clap-Grundlagen ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Warum clap?

clap (Command Line Argument Parser) ist das De-facto-Standard-Crate zum Erstellen von CLIs in Rust.

Parst Argumente, Flags und Optionen
Generiert automatisch --help und --version
Validiert Eingaben und meldet verständliche Fehler

Ohne clap müssten Sie std::env::args() manuell durchlaufen und jeden Sonderfall selbst behandeln.

Argumente von Hand lesen

Bevor Sie clap verwenden, ist es hilfreich, den direkten Ansatz zu sehen. std::env::args() liefert einen Iterator, dessen erstes Element der Programmname ist.

fn main() {
    let args: Vec<String> = std::env::args().collect();
    println!("Program: {}", args[0]);
    println!("Got {} extra arg(s)", args.len() - 1);
}

clap zu Cargo.toml hinzufügen

Um clap zu verwenden, deklarieren Sie es als Abhängigkeit. Das Feature derive aktiviert die makrobasierte API.

cargo add clap --features derive

Dieser Schritt wird in Ihrem Terminal ausgeführt und bearbeitet Ihre Projektdateien. Deshalb führen wir ihn hier nicht aus.

[dependencies]
clap = { version = "4", features = ["derive"] }

Die Builder-API

clap bietet zwei Stile. Die Builder-API erstellt ein Command zur Laufzeit, indem Methodenaufrufe verkettet werden.

use clap::{Command, Arg};

fn main() {
    let cmd = Command::new("greet")
        .arg(Arg::new("name"));
    let matches = cmd.get_matches();
    // access values from matches
}

Positionale Argumente

Ein positional argument wird anhand seiner Reihenfolge und nicht über ein Flag angegeben. Hier wird name direkt aus der Befehlszeile gelesen.

greet Alice setzt name auf Alice

use clap::{Command, Arg};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("name").required(true))
        .get_matches();
    let name = m.get_one::<String>("name").unwrap();
    println!("Hello, {}!", name);
}

Optionale Flags

Ein Flag ist ein boolescher Schalter. Verwenden Sie ArgAction::SetTrue, damit seine Anwesenheit einen booleschen Wert auf true setzt.

--loud aktiviert das Flag

use clap::{Command, Arg, ArgAction};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("loud").long("loud").action(ArgAction::SetTrue))
        .get_matches();
    let loud = m.get_flag("loud");
    println!("loud = {}", loud);
}

Optionen mit Werten

Eine Option nimmt einen Wert entgegen, etwa --count 3. Geben Sie ihr für eine komfortable Verwendung einen kurzen und einen langen Namen mit short und long.

use clap::{Command, Arg};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("count").short('c').long("count"))
        .get_matches();
    if let Some(c) = m.get_one::<String>("count") {
        println!("count = {}", c);
    }
}

Standardwerte

Geben Sie einem Argument mit default_value einen Ersatzwert, damit Benutzer es weglassen können.

Fehlt --count, wird der Wert auf 1 gesetzt

use clap::{Command, Arg};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("count").long("count").default_value("1"))
        .get_matches();
    let count = m.get_one::<String>("count").unwrap();
    println!("count = {}", count);
}

Das Ergebnis simulieren

Auch ohne installiertes clap können wir modellieren, wie die geparsten Werte aussehen. Dieses Beispiel in einfachem Rust zeigt stellvertretend die Logik, die clap für uns ausführt.

fn main() {
    let name = "Alice";
    let count: u32 = 3;
    for _ in 0..count {
        println!("Hello, {}!", name);
    }
}

Automatisch generierte Hilfe

clap erstellt --help kostenlos aus den Metadaten Ihrer Argumente. Fügen Sie about- und help-Zeichenfolgen hinzu, damit die Hilfe nützlich wird.

use clap::{Command, Arg};

fn main() {
    Command::new("greet")
        .about("Greets a person")
        .arg(Arg::new("name").help("Who to greet"))
        .get_matches();
}

Versionsflag

Legen Sie die Version einmal fest, und clap richtet --version ein. Das Makro crate_version! liest sie aus der Cargo.toml.

use clap::Command;

fn main() {
    Command::new("greet")
        .version("1.0.0")
        .get_matches();
}

Schnelltest

Testen Sie Ihr Verständnis der clap-Grundlagen.

Zusammenfassung

Sie haben die Grundlagen von clap gelernt:

Fügen Sie es mit dem Feature derive hinzu
Die Builder-API verwendet Command und Arg
Positionale Argumente werden anhand ihrer Reihenfolge verarbeitet; Flags verwenden SetTrue; Optionen nehmen Werte an
default_value stellt Ersatzwerte bereit
--help und --version werden automatisch generiert

Als Nächstes strukturieren Sie größere CLIs mit Unterbefehlen.

Häufig gestellte Fragen

Ist die Lektion „clap-Grundlagen“ kostenlos?

Ja — der vollständige Text von „clap-Grundlagen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „clap-Grundlagen“?

Argumente parsen Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „clap-Grundlagen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding