Learn Rust Coding · Aula

API de derivação

Argumentos a partir de structs

API de derivação é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

A API derive

A API derive permite descrever sua CLI como uma struct e fazer com que o clap gere o analisador por meio de #[derive(Parser)].

Menos código repetitivo que a API de construção
Segura quanto aos tipos: os campos se tornam valores tipados

Habilite-a com o recurso derive.

Uma struct Parser mínima

Anote uma struct com #[derive(Parser)] e chame Cli::parse() em main. Cada campo representa um argumento.

use clap::Parser;

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

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

O campo se torna posicional

Um campo simples como name: String é um argumento posicional obrigatório. O nome do campo se torna o nome do valor.

use clap::Parser;

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

Campos opcionais

Envolva um campo em Option para torná-lo opcional. Se o usuário omiti-lo, você obterá None.

use clap::Parser;

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

Sinalizadores curto e longo

O atributo #[arg(short, long)] deriva -v e --verbose a partir do nome do campo. Um campo bool se torna um interruptor.

use clap::Parser;

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

Valores tipados

clap analisa o valor de acordo com o tipo do campo. Um campo u32 rejeita automaticamente entradas não numéricas.

use clap::Parser;

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

Modelando um Cli analisado

Depois de analisada, uma struct Cli é apenas um conjunto de dados. Esta versão executável mostra como você usaria os campos após a análise.

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

Subcomandos como enums

Com a API derive, uma enum #[derive(Subcommand)] modela subcomandos. Cada variante representa um comando.

use clap::{Parser, Subcommand};

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

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

Analisando subcomandos de uma enum

Após Cli::parse(), analise a enum para fazer o despacho. Os dados das variantes são desempacotados de forma clara.

use clap::Parser;

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

Metadados por meio do atributo de comando

Coloque #[command(name, version, about)] na struct para definir os metadados da CLI. version pode ser lido automaticamente do Cargo.

use clap::Parser;

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

Demonstrando o despacho por enum

O padrão de correspondência com uma enum é o coração dos subcomandos derive. Veja a mesma ideia em Rust autocontido.

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"),
    }
}

Verificação rápida

Teste sua compreensão da API derive.

Recapitulação

A API derive transforma structs em analisadores:

#[derive(Parser)] junto com Cli::parse()
Campos simples são posicionais; Option os torna opcionais
#[arg(short, long)] deriva sinalizadores e opções
Enums #[derive(Subcommand)] modelam subcomandos

A seguir: validação e uma saída de ajuda aprimorada.

Perguntas Frequentes

A aula “API de derivação” é grátis?

Sim — o texto completo de “API de derivação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “API de derivação”?

Argumentos a partir de structs Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “API de derivação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding