Learn Rust Coding · Lekcja

Podstawy clap

Analizowanie argumentów

Lekcja 1 z 413 kroki

Podstawy clap to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 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.

Po co clap?

clap (Command Line Argument Parser) to faktyczny standardowy crate do tworzenia interfejsów CLI w Rust.

Analizuje argumenty, flagi i opcje
Automatycznie generuje --help i --version
Sprawdza dane wejściowe i zgłasza zrozumiałe błędy

Bez niego trzeba byłoby ręcznie iterować po std::env::args() i samodzielnie obsługiwać każdy przypadek brzegowy.

Ręczne odczytywanie argumentów

Zanim sięgnie Pan/Pani po clap, warto zobaczyć podejście niskopoziomowe. std::env::args() zwraca iterator, którego pierwszy element to nazwa programu.

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

Dodawanie clap do Cargo.toml

Aby używać clap, należy zadeklarować go jako zależność. Funkcja derive udostępnia API oparte na makrach.

cargo add clap --features derive

Ten krok wykonuje się w terminalu i modyfikuje pliki projektu, dlatego nie jest tutaj uruchamiany.

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

Builder API

clap oferuje dwa style. Builder API tworzy obiekt Command w czasie działania programu, łącząc wywołania metod.

use clap::{Command, Arg};

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

Argumenty pozycyjne

Argument pozycyjny jest przekazywany na podstawie kolejności, a nie za pomocą flagi. W tym przypadku name jest odczytywane bezpośrednio z wiersza poleceń.

greet Alice ustawia name na 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);
}

Opcjonalne flagi

Flaga jest przełącznikiem wartości logicznej. Należy użyć ArgAction::SetTrue, aby jej obecność ustawiła wartość bool.

--loud włącza 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);
}

Opcje z wartościami

Opcja przyjmuje wartość, na przykład --count 3. Należy nadać jej nazwę short i long, aby korzystanie z niej było wygodne.

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

Wartości domyślne

Należy nadać argumentowi wartość zastępczą za pomocą default_value, aby użytkownicy mogli go pominąć.

Jeśli brakuje --count, wartość zostaje ustawiona na 1

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

Symulowanie wyniku

Nawet bez zainstalowanego clap możemy zamodelować wygląd przeanalizowanych wartości. Oto przykład w czystym Rust, pokazujący logikę, którą clap wykonuje za nas.

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

Automatycznie generowana pomoc

clap bez dodatkowej pracy tworzy --help na podstawie metadanych argumentów. Należy dodać ciągi about i help, aby komunikat był użyteczny.

use clap::{Command, Arg};

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

Flaga wersji

Wystarczy raz ustawić wersję, a clap skonfiguruje --version. Makro crate_version! pobiera ją z Cargo.toml.

use clap::Command;

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

Szybkie sprawdzenie

Sprawdźmy, czy zna Pan/Pani podstawy clap.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Poznał(a) Pan/Pani podstawy clap:

Należy dodać go z funkcją derive
Builder API używa Command i Arg
Argumenty pozycyjne zależą od kolejności, flagi używają SetTrue, a opcje przyjmują wartości
default_value dostarcza wartości zastępcze
--help i --version są generowane automatycznie

W następnym kroku uporządkuje Pan/Pani większe interfejsy CLI za pomocą podkomend.

Bezpłatny start

Ucz się Rust dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 39
Lekcje: 144

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Podstawy clap” jest bezpłatna?

Tak — pełny tekst „Podstawy clap” 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 „Podstawy clap”?

Analizowanie argumentów Ć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 1 z 4.

Ile czasu zajmuje lekcja „Podstawy clap”?

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