Learn Rust Coding · Lekcja

Podkomendy

Uporządkowane interfejsy CLI

Podkomendy to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Czym są podkomendy?

Podkomendy pozwalają jednemu plikowi binarnemu udostępniać kilka działań, takich jak git commit i git push.

Każda podkomenda ma własne argumenty
Struktura skaluje się wraz z rozwojem interfejsu CLI

clap odwzorowuje je za pomocą zagnieżdżonych wartości Command.

Dodawanie podkomendy

Należy dołączyć polecenie podrzędne za pomocą .subcommand(). Polecenie nadrzędne staje się dyspozytorem.

use clap::Command;

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

Dopasowywanie wybranej podkomendy

Po przeanalizowaniu argumentów subcommand() informuje, które polecenie podrzędne zostało uruchomione. Należy dopasować jego nazwę, aby przekazać sterowanie.

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"),
    }
}

Argumenty w podkomendzie

Podkomenda ma własne argumenty. Polecenie add poniżej przyjmuje opis zadania.

use clap::{Command, Arg};

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

Odczytywanie argumentów podkomendy

Drugi element krotki to podrzędny ArgMatches. Wartości pobiera się z niego tak samo jak z poziomu głównego.

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

Wymaganie podkomendy

Należy użyć subcommand_required(true), aby uruchomienie samego pliku binarnego wyświetlało pomoc zamiast nie robić nic.

use clap::Command;

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

Modelowanie dyspozycji w czystym Rust

Podstawą interfejsu CLI z podkomendami jest dopasowanie do ciągu znaków. Ten uruchamialny przykład odwzorowuje tę logikę przekazywania sterowania.

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

Zagnieżdżone podkomendy

Podkomendy mogą mieć własne podkomendy, np. cargo build --release w porównaniu z głębszymi drzewami. Wystarczy zagnieżdżać kolejne wywołania .subcommand().

use clap::Command;

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

Pomoc dla każdej podkomendy

Każda podkomenda ma własną stronę pomocy --help. Dodaj ciąg about, aby ją opisać.

use clap::Command;

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

Aliasy

Udostępnij użytkownikom skróty za pomocą visible_alias. Teraz ls działa tak samo jak list.

use clap::Command;

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

Zwracanie kodów wyjścia

Dopracowany CLI sygnalizuje powodzenie lub błąd. Zwróć niezerowy kod z podkomendy za pomocą std::process::exit albo zwracając Result z funkcji main.

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

Szybkie sprawdzenie

Sprawdź swoją wiedzę o podkomendach.

Podsumowanie

Potrafisz już budować uporządkowane interfejsy CLI z użyciem podkomend:

Dodawaj elementy podrzędne za pomocą .subcommand()
Przekazuj obsługę, dopasowując wynik m.subcommand()
Każda podkomenda ma własne argumenty i stronę pomocy
Używaj subcommand_required i aliasów, aby dopracować interfejs

Dalej: API derive zamienia struktury w parsery argumentów.

Często zadawane pytania

Czy lekcja „Podkomendy” jest bezpłatna?

Tak — pełny tekst „Podkomendy” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Podkomendy”?

Uporządkowane interfejsy CLI Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Podkomendy”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding