API de dérivation
Arguments issus de structures
API de dérivation est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
L’interface derive
L’interface derive vous permet de décrire votre CLI sous forme de structure et de laisser clap générer l’analyseur via #[derive(Parser)].
- Moins de code répétitif que l’interface de construction
- Sûre du point de vue des types : les champs deviennent des valeurs typées
Activez-la avec la fonctionnalité derive.
Une structure Parser minimale
Annotez une structure avec #[derive(Parser)] et appelez Cli::parse() dans main. Chaque champ correspond à un argument.
use clap::Parser;
#[derive(Parser)]
struct Cli {
name: String,
}
fn main() {
let cli = Cli::parse();
println!("Hello, {}!", cli.name);
}Un champ devient positionnel
Un champ simple comme name: String est un argument positionnel obligatoire. Le nom du champ devient le nom de sa valeur.
use clap::Parser;
#[derive(Parser)]
struct Cli {
input: String,
output: String,
}Champs facultatifs
Enveloppez un champ dans Option pour le rendre facultatif. Si l’utilisateur l’omet, vous obtenez None.
use clap::Parser;
#[derive(Parser)]
struct Cli {
#[arg(short, long)]
config: Option<String>,
}Indicateurs et noms courts/longs
L’attribut #[arg(short, long)] déduit -v et --verbose à partir du nom du champ. Un champ bool devient un commutateur.
use clap::Parser;
#[derive(Parser)]
struct Cli {
#[arg(short, long)]
verbose: bool,
}Valeurs typées
clap analyse la valeur selon le type du champ. Un champ u32 rejette automatiquement les entrées non numériques.
use clap::Parser;
#[derive(Parser)]
struct Cli {
#[arg(short, long, default_value_t = 1)]
count: u32,
}Modéliser un Cli analysé
Une fois analysée, une structure Cli ne contient que des données ordinaires. Cette version exécutable montre comment utiliser les champs après l’analyse.
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);
}
}Les sous-commandes sous forme d’énumérations
Avec l’interface derive, une énumération #[derive(Subcommand)] modélise les sous-commandes. Chaque variante est une commande.
use clap::{Parser, Subcommand};
#[derive(Parser)]
struct Cli {
#[command(subcommand)]
cmd: Commands,
}
#[derive(Subcommand)]
enum Commands {
Add { task: String },
List,
}Faire correspondre les sous-commandes d’une énumération
Après Cli::parse(), faites correspondre l’énumération pour effectuer la répartition. Les données des variantes se déstructurent proprement.
use clap::Parser;
fn run(cli: Cli) {
match cli.cmd {
Commands::Add { task } => println!("add {}", task),
Commands::List => println!("list"),
}
}Métadonnées via l’attribut command
Placez #[command(name, version, about)] sur la structure pour définir les métadonnées du CLI. version peut être lue automatiquement depuis Cargo.
use clap::Parser;
#[derive(Parser)]
#[command(name = "greet", version, about = "Greets people")]
struct Cli {
name: String,
}Démontrer la répartition par énumération
Le modèle de correspondance sur une énumération est au cœur des sous-commandes derive. Voici la même idée dans un code Rust autonome.
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"),
}
}Vérification rapide
Vérifiez votre compréhension de l’interface derive.
Récapitulatif
L’interface derive transforme les structures en analyseurs :
#[derive(Parser)]associé àCli::parse()- Les champs simples sont positionnels ;
Optionles rend facultatifs #[arg(short, long)]déduit les indicateurs et les options- Les énumérations
#[derive(Subcommand)]modélisent les sous-commandes
Ensuite : validation et affichage d’aide soigné.
Apprends Rust avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 39
- Leçons
- 144
Questions Fréquemment Posées
La leçon « API de dérivation » est-elle gratuite ?
Oui — le texte complet de « API de dérivation » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « API de dérivation » ?
Arguments issus de structures Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « API de dérivation » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Bases de clap
- Sous-commandes
- API de dérivation
- Validation et aide