Learn Rust Coding · Lezione

Validazione e guida

CLI curate

Validazione e guida è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.

Perfezionare la CLI

Una CLI efficace convalida subito l'input e offre un help chiaro. clap supporta entrambe le esigenze tramite attributi e parser dei valori.

Rifiuti i valori errati con messaggi comprensibili
Documenti ogni argomento

Intervalli di valori

Limiti un argomento numerico a un intervallo con value_parser. Gli input fuori intervallo vengono rifiutati automaticamente.

use clap::Parser;

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

Scelte enumerate

Usi #[derive(ValueEnum)] per limitare un argomento a un insieme fisso di stringhe.

use clap::{Parser, ValueEnum};

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

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

Funzione di validazione personalizzata

Passi a value_parser una funzione che restituisce Result. clap trasforma un Err in un errore di utilizzo.

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

Provare la logica di validazione

La funzione di validazione è semplice Rust. La esegua per vedere come un controllo di pari o dispari restituisce Ok oppure 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"));
}

Gruppi obbligatori e conflitti

Esprima le relazioni tra gli argomenti. conflicts_with impedisce di usare insieme due flag incompatibili.

use clap::Parser;

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

Testo di help per ogni campo

Un commento di documentazione sopra un campo diventa il relativo testo di help. Questo è il modo idiomatico per documentare gli argomenti.

use clap::Parser;

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

Help esteso e help breve

clap mostra un riepilogo breve per -h e il testo completo per --help. Quando necessario, li separi con #[arg(short_help, long_help)].

use clap::Parser;

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

Restituire Result da main

Per gli errori di runtime che si verificano dopo l'analisi, restituisca Result da main. L'operatore ? propaga gli errori e i programmi senza clap li stampano terminando con un codice diverso da zero.

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

Stile degli errori personalizzato

clap formatta automaticamente gli errori di utilizzo, ma può crearne di personalizzati con clap::Error e cmd.error() per messaggi specifici del contesto.

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

Riepilogo della validazione in Rust semplice

L'essenza della validazione di una CLI consiste nel controllare un valore e segnalare un errore chiaro. Ecco il processo completo.

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 rapida

Verifichi la Sua comprensione della validazione e dell'help.

Riepilogo

Ora può creare CLI perfezionate:

value_parser applica intervalli e regole personalizzate
ValueEnum limita le scelte
conflicts_with modella i flag incompatibili
I commenti di documentazione diventano testo di help
Restituisca Result da main per gli errori di runtime

Il corso su clap è completo.

Domande Frequenti

La lezione «Validazione e guida» è gratuita?

Sì — il testo completo di «Validazione e guida» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.

Cosa imparerò in «Validazione e guida»?

CLI curate Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Validazione e guida»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Learn Rust Coding