Learn Rust Coding · Leçon

Validation et aide

CLI soignées

Validation et aide est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 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.

Peaufiner votre CLI

Un CLI de qualité valide rapidement les entrées et fournit une aide claire. clap prend en charge ces deux aspects avec des attributs et des analyseurs de valeurs.

Rejetez les valeurs incorrectes avec des messages compréhensibles
Documentez chaque argument

Plages de valeurs

Limitez un argument numérique à une plage avec value_parser. Les entrées hors plage sont automatiquement rejetées.

use clap::Parser;

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

Choix énumérés

Utilisez #[derive(ValueEnum)] pour limiter un argument à un ensemble fixe de chaînes.

use clap::{Parser, ValueEnum};

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

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

Fonction de validation personnalisée

Passez à value_parser une fonction qui renvoie Result. clap transforme une valeur Err en erreur d’utilisation.

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

Essayer la logique de validation

La fonction de validation est du Rust ordinaire. Exécutez-la pour voir comment une vérification pair/impair renvoie 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"));
}

Groupes obligatoires et conflits

Exprimez les relations entre les arguments. conflicts_with empêche l’utilisation simultanée de deux indicateurs incompatibles.

use clap::Parser;

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

Texte d’aide pour chaque champ

Un commentaire de documentation placé au-dessus d’un champ devient son texte d’aide. C’est la manière idiomatique de documenter les arguments.

use clap::Parser;

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

Aide longue et aide courte

clap affiche un résumé court pour -h et le texte complet pour --help. Séparez-les avec #[arg(short_help, long_help)] lorsque cela est nécessaire.

use clap::Parser;

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

Renvoyer Result depuis main

Pour les erreurs d’exécution qui surviennent après l’analyse, renvoyez Result depuis main. L’opérateur ? propage les erreurs, et les programmes sans clap les affichent avec un code de sortie différent de zéro.

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

Personnaliser le style des erreurs

clap met automatiquement en forme les erreurs d’utilisation, mais vous pouvez créer les vôtres avec clap::Error et cmd.error() pour afficher des messages adaptés au contexte.

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

Résumé de la validation en Rust simple

L’essentiel de la validation d’une CLI consiste à vérifier une valeur et à signaler clairement l’erreur. Voici le processus complet.

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

Vérification rapide

Vérifiez votre compréhension de la validation et de l’aide.

Récapitulatif

Vous pouvez maintenant créer des CLI soignées :

value_parser impose des plages et des règles personnalisées
ValueEnum limite les choix
conflicts_with modélise les options incompatibles
Les commentaires de documentation deviennent le texte d’aide
Renvoyez Result depuis main pour les erreurs d’exécution

Vous avez terminé le cours sur clap.

Questions Fréquemment Posées

La leçon « Validation et aide » est-elle gratuite ?

Oui — le texte complet de « Validation et aide » 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 « Validation et aide » ?

CLI soignées 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 4 sur 4.

Combien de temps prend la leçon « Validation et aide » ?

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

← Retour à Learn Rust Coding