Learn Rust Coding · Lekcja

Walidacja i pomoc

Dopracowane interfejsy CLI

Walidacja i pomoc to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 4 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.

Dopracowywanie CLI

Dobry CLI wcześnie sprawdza poprawność danych wejściowych i oferuje przejrzystą pomoc. clap obsługuje oba te zadania za pomocą atrybutów i parserów wartości.

Odrzucaj nieprawidłowe wartości, wyświetlając przyjazne komunikaty
Dokumentuj każdy argument

Zakresy wartości

Ogranicz argument liczbowy do zakresu za pomocą value_parser. Wartości spoza zakresu są automatycznie odrzucane.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    #[arg(long, value_parser = clap::value_parser!(u16).range(1..=65535))]
    port: u16,
}

Wybór z określonego zbioru

Użyj #[derive(ValueEnum)], aby ograniczyć argument do ustalonego zbioru ciągów znaków.

use clap::{Parser, ValueEnum};

#[derive(Clone, ValueEnum)]
enum Mode { Fast, Safe }

#[derive(Parser)]
struct Cli {
    #[arg(long, value_enum)]
    mode: Mode,
}

Niestandardowa funkcja walidująca

Przekaż do value_parser funkcję, która zwraca Result. clap zamienia wartość Err na błąd użycia.

fn parse_even(s: &str) -> Result<u32, String> {
    let n: u32 = s.parse().map_err(|_| "not a number".to_string())?;
    if n % 2 == 0 { Ok(n) } else { Err("must be even".to_string()) }
}

Wypróbowanie logiki walidacji

Funkcja walidująca to zwykły kod Rust. Uruchom ją, aby zobaczyć, jak sprawdzenie parzystości zwraca Ok lub Err.

fn parse_even(s: &str) -> Result<u32, String> {
    let n: u32 = s.parse().map_err(|_| "not a number".to_string())?;
    if n % 2 == 0 { Ok(n) } else { Err("must be even".to_string()) }
}

fn main() {
    println!("{:?}", parse_even("4"));
    println!("{:?}", parse_even("7"));
}

Wymagane grupy i konflikty

Wyrażaj zależności między argumentami. conflicts_with uniemożliwia jednoczesne użycie dwóch niezgodnych flag.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    #[arg(long)]
    quiet: bool,
    #[arg(long, conflicts_with = "quiet")]
    verbose: bool,
}

Tekst pomocy dla każdego pola

Komentarz dokumentacyjny nad polem staje się jego tekstem pomocy. To idiomatyczny sposób dokumentowania argumentów.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    /// The file to process
    input: String,
}

Długa i krótka pomoc

clap wyświetla krótkie podsumowanie dla -h i pełny tekst dla --help. W razie potrzeby rozdziel je za pomocą #[arg(short_help, long_help)].

use clap::Parser;

#[derive(Parser)]
struct Cli {
    #[arg(long, long_help = "A detailed explanation shown only with --help")]
    flag: bool,
}

Zwracanie Result z funkcji main

W przypadku błędów czasu wykonywania po parsowaniu zwracaj Result z funkcji main. Operator ? przekazuje błędy dalej, a programy niezależne od clap wyświetlają je i kończą działanie z niezerowym kodem.

fn main() -> Result<(), String> {
    let value = "42";
    let n: i32 = value.parse().map_err(|_| "bad number".to_string())?;
    println!("parsed {}", n);
    Ok(())
}

Niestandardowe formatowanie błędów

clap automatycznie formatuje błędy użycia, ale możesz utworzyć własne za pomocą clap::Error i cmd.error(), aby wyświetlać komunikaty dostosowane do kontekstu.

use clap::{CommandFactory, Parser};

#[derive(Parser)]
struct Cli { value: i32 }

fn fail() {
    let mut cmd = Cli::command();
    cmd.error(clap::error::ErrorKind::ValueValidation, "value too large").exit();
}

Podsumowanie walidacji w zwykłym Rust

Istotą walidacji CLI jest sprawdzenie wartości i zgłoszenie jasnego błędu. Oto cały proces od początku do końca.

fn validate_port(p: u32) -> Result<u32, String> {
    if (1..=65535).contains(&p) { Ok(p) }
    else { Err(format!("port {} out of range", p)) }
}

fn main() {
    match validate_port(8080) {
        Ok(p) => println!("using port {}", p),
        Err(e) => eprintln!("error: {}", e),
    }
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę o walidacji i pomocy.

Podsumowanie

Potrafisz już budować dopracowane interfejsy CLI:

value_parser wymusza zakresy i niestandardowe reguły
ValueEnum ogranicza dostępne opcje
conflicts_with opisuje niezgodne flagi
Komentarze dokumentacyjne stają się tekstem pomocy
Zwracaj Result z funkcji main w przypadku błędów czasu wykonywania

To kończy kurs clap.

Często zadawane pytania

Czy lekcja „Walidacja i pomoc” jest bezpłatna?

Tak — pełny tekst „Walidacja i pomoc” 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 „Walidacja i pomoc”?

Dopracowane 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 4 z 4.

Ile czasu zajmuje lekcja „Walidacja i pomoc”?

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