Derive-API
Args aus Structs
Derive-API ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 3 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.
Die derive API
Mit der derive API beschreiben Sie Ihre CLI als Struct und lassen clap den Parser über #[derive(Parser)] erzeugen.
- Weniger Boilerplate als bei der builder API
- Typsicher: Felder werden zu typisierten Werten
Aktivieren Sie sie mit dem Feature derive.
Ein minimales Parser-Struct
Annotieren Sie ein Struct mit #[derive(Parser)] und rufen Sie in main Cli::parse() auf. Jedes Feld ist ein Argument.
use clap::Parser;
#[derive(Parser)]
struct Cli {
name: String,
}
fn main() {
let cli = Cli::parse();
println!("Hello, {}!", cli.name);
}Feld wird zum Positionsargument
Ein einfaches Feld wie name: String ist ein erforderliches Positionsargument. Der Feldname wird zu seinem Wertnamen.
use clap::Parser;
#[derive(Parser)]
struct Cli {
input: String,
output: String,
}Optionale Felder
Umschließen Sie ein Feld mit Option, um es optional zu machen. Wenn der Benutzer es weglässt, erhalten Sie None.
use clap::Parser;
#[derive(Parser)]
struct Cli {
#[arg(short, long)]
config: Option<String>,
}Flags und Kurz-/Langform
Das Attribut #[arg(short, long)] leitet aus dem Feldnamen -v und --verbose ab. Ein Feld vom Typ bool wird zu einem Schalter.
use clap::Parser;
#[derive(Parser)]
struct Cli {
#[arg(short, long)]
verbose: bool,
}Typisierte Werte
clap parst in den Typ des Feldes. Ein Feld vom Typ u32 weist nicht numerische Eingaben automatisch zurück.
use clap::Parser;
#[derive(Parser)]
struct Cli {
#[arg(short, long, default_value_t = 1)]
count: u32,
}Ein geparstes Cli modellieren
Nach dem Parsen enthält ein Cli-Struct einfache Daten. Diese ausführbare Version zeigt, wie Sie die Felder nach dem Parsen verwenden.
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);
}
}Unterbefehle als Enums
Mit der derive API bildet ein Enum mit #[derive(Subcommand)] die Unterbefehle ab. Jede Variante ist ein Befehl.
use clap::{Parser, Subcommand};
#[derive(Parser)]
struct Cli {
#[command(subcommand)]
cmd: Commands,
}
#[derive(Subcommand)]
enum Commands {
Add { task: String },
List,
}Enum-Unterbefehle abgleichen
Nach Cli::parse() gleichen Sie das Enum ab, um die Weiterleitung vorzunehmen. Die Daten der Variante lassen sich übersichtlich destrukturieren.
use clap::Parser;
fn run(cli: Cli) {
match cli.cmd {
Commands::Add { task } => println!("add {}", task),
Commands::List => println!("list"),
}
}Metadaten über das command-Attribut
Setzen Sie #[command(name, version, about)] auf das Struct, um die CLI-Metadaten festzulegen. version kann die Version automatisch aus Cargo lesen.
use clap::Parser;
#[derive(Parser)]
#[command(name = "greet", version, about = "Greets people")]
struct Cli {
name: String,
}Enum-Weiterleitung demonstrieren
Das Muster, bei dem anhand eines Enums abgeglichen wird, bildet den Kern von derive-Unterbefehlen. Hier sehen Sie dieselbe Idee in eigenständigem 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"),
}
}Kurzer Test
Testen Sie Ihr Verständnis der derive API.
Zusammenfassung
Die derive API macht aus Structs Parser:
#[derive(Parser)]zusammen mitCli::parse()- Einfache Felder sind Positionsargumente;
Optionmacht sie optional #[arg(short, long)]leitet Flags und Optionen ab- Enums mit
#[derive(Subcommand)]bilden Unterbefehle ab
Als Nächstes folgen Validierung und eine ausgereifte Hilfsausgabe.
Häufig gestellte Fragen
Ist die Lektion „Derive-API“ kostenlos?
Ja — der vollständige Text von „Derive-API“ 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 „Derive-API“?
Args aus Structs 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 3 von 4.
Wie lange dauert die Lektion „Derive-API“?
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.