Learn Rust Coding · Aula

Validação e ajuda

CLIs refinadas

Validação e ajuda é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 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.

Aprimorando sua CLI

Uma CLI excelente valida a entrada antecipadamente e oferece uma ajuda clara. O clap é compatível com ambos por meio de atributos e analisadores de valores.

Rejeite valores inválidos com mensagens claras
Documente cada argumento

Intervalos de valores

Restrinja um argumento numérico a um intervalo com value_parser. Entradas fora do intervalo são rejeitadas automaticamente.

use clap::Parser;

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

Opções enumeradas

Use #[derive(ValueEnum)] para restringir um argumento a um conjunto fixo de strings.

use clap::{Parser, ValueEnum};

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

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

Função de validação personalizada

Transmita para value_parser uma função que retorne Result. O clap transforma um Err em um erro de uso.

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

Testando a lógica de validação

A função de validação é Rust puro. Execute-a para ver como uma verificação de paridade retorna Ok ou 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"));
}

Grupos obrigatórios e conflitos

Expresse relações entre args. conflicts_with impede que dois sinalizadores incompatíveis sejam usados juntos.

use clap::Parser;

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

Texto de ajuda por campo

Um comentário de documentação acima de um campo torna-se o texto de ajuda correspondente. Esta é a forma idiomática de documentar argumentos.

use clap::Parser;

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

Ajuda longa e ajuda curta

clap mostra um resumo curto para -h e o texto completo para --help. Separe-os com #[arg(short_help, long_help)] quando necessário.

use clap::Parser;

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

Retornando Result de main

Para erros de execução que ocorram após a análise, retorne Result de main. O operador ? propaga os erros, e programas sem clap os exibem com um código de saída diferente de zero.

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

Estilo personalizado de erros

clap formata erros de uso automaticamente, mas você pode criar os seus próprios com clap::Error e cmd.error() para mensagens específicas do contexto.

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

Resumo da validação em Rust puro

A essência da validação de CLI é verificar um valor e relatar um erro claro. Veja o processo completo de ponta a ponta.

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

Verificação rápida

Teste sua compreensão sobre validação e ajuda.

Recapitulação

Agora você pode criar CLIs refinadas:

value_parser impõe limites e regras personalizadas
ValueEnum limita as opções
conflicts_with representa sinalizadores incompatíveis
Comentários de documentação tornam-se texto de ajuda
Retorne Result de main para erros de execução

Isso conclui o curso de clap.

Perguntas Frequentes

A aula “Validação e ajuda” é grátis?

Sim — o texto completo de “Validação e ajuda” é 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 “Validação e ajuda”?

CLIs refinadas 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 4 de 4.

Quanto tempo leva a aula “Validação e ajuda”?

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