Learn Rust Coding · Lektion

Unterbefehle

Strukturierte CLIs

Unterbefehle ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Was sind Unterbefehle?

Unterbefehle ermöglichen es einem Binärprogramm, mehrere Aktionen bereitzustellen, etwa git commit und git push.

Jeder Unterbefehl hat eigene Argumente
Die Struktur lässt sich erweitern, wenn Ihre CLI wächst

clap bildet diese mit verschachtelten Command-Werten ab.

Einen Unterbefehl hinzufügen

Fügen Sie mit .subcommand() einen untergeordneten Befehl hinzu. Der übergeordnete Befehl wird dadurch zum Dispatcher.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand(Command::new("add"))
        .subcommand(Command::new("list"))
        .get_matches();
}

Den ausgewählten Unterbefehl abgleichen

Nach dem Parsen teilt Ihnen subcommand() mit, welcher untergeordnete Befehl ausgeführt wurde. Prüfen Sie seinen Namen mit match, um die Verarbeitung weiterzuleiten.

use clap::Command;

fn main() {
    let m = Command::new("todo")
        .subcommand(Command::new("add"))
        .subcommand(Command::new("list"))
        .get_matches();
    match m.subcommand() {
        Some(("add", _)) => println!("adding"),
        Some(("list", _)) => println!("listing"),
        _ => println!("no subcommand"),
    }
}

Argumente in einem Unterbefehl

Ein Unterbefehl enthält eigene Argumente. Der Befehl add unten nimmt eine Aufgabenbeschreibung entgegen.

use clap::{Command, Arg};

fn main() {
    Command::new("todo")
        .subcommand(
            Command::new("add")
                .arg(Arg::new("task").required(true))
        )
        .get_matches();
}

Argumente des Unterbefehls lesen

Das zweite Tupelelement ist das ArgMatches des Unterbefehls. Rufen Sie daraus Werte genauso ab wie auf der obersten Ebene.

use clap::{Command, Arg};

fn main() {
    let m = Command::new("todo")
        .subcommand(Command::new("add").arg(Arg::new("task")))
        .get_matches();
    if let Some(("add", sub)) = m.subcommand() {
        let task = sub.get_one::<String>("task").unwrap();
        println!("add: {}", task);
    }
}

Einen Unterbefehl voraussetzen

Verwenden Sie subcommand_required(true), damit das Ausführen des Binärprogramms ohne Argumente die Hilfe ausgibt, statt nichts zu tun.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand_required(true)
        .arg_required_else_help(true)
        .subcommand(Command::new("list"))
        .get_matches();
}

Dispatching in einfachem Rust modellieren

Der Kern einer CLI mit Unterbefehlen ist ein match auf einer Zeichenfolge. Dieses ausführbare Beispiel bildet diese Dispatch-Logik nach.

fn main() {
    let cmd = "add";
    let task = "Buy milk";
    match cmd {
        "add" => println!("Added: {}", task),
        "list" => println!("Listing tasks"),
        other => println!("Unknown command: {}", other),
    }
}

Verschachtelte Unterbefehle

Unterbefehle können selbst weitere Unterbefehle enthalten, z. B. cargo build --release oder noch tiefere Strukturen. Verschachteln Sie einfach weitere Aufrufe von .subcommand().

use clap::Command;

fn main() {
    Command::new("app")
        .subcommand(
            Command::new("config")
                .subcommand(Command::new("get"))
                .subcommand(Command::new("set"))
        )
        .get_matches();
}

Hilfe pro Unterbefehl

Jeder Unterbefehl erhält eine eigene --help-Seite. Fügen Sie eine about-Zeichenkette hinzu, um ihn zu beschreiben.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand(
            Command::new("add").about("Add a new task")
        )
        .get_matches();
}

Aliase

Geben Sie Benutzern mit visible_alias Kurzbefehle. Nun funktioniert ls ebenso wie list.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand(
            Command::new("list").visible_alias("ls")
        )
        .get_matches();
}

Exit-Codes zurückgeben

Eine ausgereifte CLI signalisiert Erfolg oder Fehler. Geben Sie aus einem Unterbefehl einen von null verschiedenen Code mit std::process::exit zurück oder geben Sie aus main ein Result zurück.

fn main() {
    let success = true;
    if !success {
        std::process::exit(1);
    }
    println!("ok");
}

Kurzer Test

Testen Sie Ihr Verständnis von Unterbefehlen.

Zusammenfassung

Sie erstellen nun strukturierte CLIs mit Unterbefehlen:

Fügen Sie Unterbefehle mit .subcommand() hinzu
Leiten Sie mit einem Abgleich von m.subcommand() weiter
Jeder Unterbefehl besitzt eigene Argumente und eine eigene Hilfeseite
Verwenden Sie subcommand_required und Aliase für den letzten Feinschliff

Als Nächstes macht die derive API aus Structs Argument-Parser.

Häufig gestellte Fragen

Ist die Lektion „Unterbefehle“ kostenlos?

Ja — der vollständige Text von „Unterbefehle“ 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 „Unterbefehle“?

Strukturierte CLIs 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 2 von 4.

Wie lange dauert die Lektion „Unterbefehle“?

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