Learn Rust Coding · Lekcja

API derive

Argumenty ze struktur

API derive to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 3 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.

API derive

API derive pozwala opisać CLI jako strukturę i zlecić clap wygenerowanie parsera za pomocą #[derive(Parser)].

Mniej kodu pomocniczego niż w builder API
Bezpieczne typowo: pola stają się wartościami określonych typów

Włącz je za pomocą funkcji derive.

Minimalna struktura Parser

Oznacz strukturę adnotacją #[derive(Parser)] i wywołaj Cli::parse() w funkcji main. Każde pole jest jednym argumentem.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    name: String,
}

fn main() {
    let cli = Cli::parse();
    println!("Hello, {}!", cli.name);
}

Pole staje się argumentem pozycyjnym

Zwykłe pole, takie jak name: String, jest wymaganym argumentem pozycyjnym. Nazwa pola staje się nazwą jego wartości.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    input: String,
    output: String,
}

Pola opcjonalne

Owiń pole w Option, aby uczynić je opcjonalnym. Jeśli użytkownik je pominie, otrzymasz None.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    #[arg(short, long)]
    config: Option<String>,
}

Flagi oraz krótka i długa forma

Atrybut #[arg(short, long)] wyprowadza -v i --verbose z nazwy pola. Pole typu bool staje się przełącznikiem.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    #[arg(short, long)]
    verbose: bool,
}

Wartości typowane

clap parsuje dane do typu pola. Pole typu u32 automatycznie odrzuca dane wejściowe, które nie są liczbami.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    #[arg(short, long, default_value_t = 1)]
    count: u32,
}

Modelowanie sparsowanego Cli

Po sparsowaniu struktura Cli jest zwykłymi danymi. Ta wersja, którą można uruchomić, pokazuje, jak używać pól po parsowaniu.

struct Cli {
    name: String,
    count: u32,
    verbose: bool,
}

fn main() {
    let cli = Cli { name: "Alice".to_string(), count: 2, verbose: true };
    for _ in 0..cli.count {
        println!("Hello, {}! (verbose={})", cli.name, cli.verbose);
    }
}

Podkomendy jako wyliczenia

W API derive wyliczenie oznaczone #[derive(Subcommand)] modeluje podkomendy. Każdy wariant jest poleceniem.

use clap::{Parser, Subcommand};

#[derive(Parser)]
struct Cli {
    #[command(subcommand)]
    cmd: Commands,
}

#[derive(Subcommand)]
enum Commands {
    Add { task: String },
    List,
}

Dopasowywanie podkomend wyliczenia

Po wywołaniu Cli::parse() dopasuj wyliczenie, aby przekazać obsługę. Dane wariantu można łatwo rozłożyć.

use clap::Parser;

fn run(cli: Cli) {
    match cli.cmd {
        Commands::Add { task } => println!("add {}", task),
        Commands::List => println!("list"),
    }
}

Metadane za pomocą atrybutu command

Umieść #[command(name, version, about)] na strukturze, aby ustawić metadane CLI. version może być automatycznie odczytywane z Cargo.

use clap::Parser;

#[derive(Parser)]
#[command(name = "greet", version, about = "Greets people")]
struct Cli {
    name: String,
}

Prezentacja przekazywania obsługi wyliczenia

Wzorzec dopasowywania wyliczenia jest podstawą podkomend korzystających z derive. Oto ta sama idea w samodzielnym kodzie Rust.

enum Command {
    Add(String),
    List,
}

fn main() {
    let cmd = Command::Add("Write code".to_string());
    match cmd {
        Command::Add(task) => println!("Added: {}", task),
        Command::List => println!("Listing"),
    }
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę o API derive.

Podsumowanie

API derive zamienia struktury w parsery:

#[derive(Parser)] wraz z Cli::parse()
Zwykłe pola są argumentami pozycyjnymi, a Option czyni je opcjonalnymi
#[arg(short, long)] wyprowadza flagi i opcje
Wyliczenia z #[derive(Subcommand)] modelują podkomendy

Dalej: walidacja i dopracowany tekst pomocy.

Często zadawane pytania

Czy lekcja „API derive” jest bezpłatna?

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

Argumenty ze struktur Ć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 3 z 4.

Ile czasu zajmuje lekcja „API derive”?

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