Learn Rust Coding · Lección

Validación y ayuda

CLIs pulidas

Validación y ayuda es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

Perfeccionar su CLI

Una CLI excelente valida la entrada de antemano y ofrece una ayuda clara. clap admite ambas cosas mediante atributos y analizadores de valores.

Rechace valores incorrectos con mensajes claros
Documente cada argumento

Rangos de valores

Restrinja un argumento numérico a un rango con value_parser. Las entradas fuera del rango se rechazan automáticamente.

use clap::Parser;

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

Opciones enumeradas

Use #[derive(ValueEnum)] para limitar un argumento a un conjunto fijo de cadenas.

use clap::{Parser, ValueEnum};

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

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

Función de validación personalizada

Proporcione a value_parser una función que devuelva Result. clap convierte un Err en un error 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()) }
}

Probar la lógica de validación

La función de validación es Rust básico. Ejecútela para ver cómo una comprobación de paridad devuelve Ok o 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 obligatorios y conflictos

Exprese relaciones entre argumentos. conflicts_with impide usar conjuntamente dos flags incompatibles.

use clap::Parser;

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

Texto de ayuda por campo

Un comentario de documentación situado sobre un campo se convierte en su texto de ayuda. Esta es la forma idiomática de documentar los argumentos.

use clap::Parser;

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

Ayuda larga frente a ayuda corta

clap muestra un resumen breve para -h y el texto completo para --help. Si es necesario, sepárelos 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,
}

Devolver Result desde main

Para los errores en tiempo de ejecución posteriores al análisis, devuelva Result desde main. El operador ? propaga los errores y los programas sin clap los muestran con una salida distinta de cero.

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

Personalizar el estilo de los errores

clap da formato automáticamente a los errores de uso, pero puede crear los suyos con clap::Error y cmd.error() para mostrar mensajes específicos del 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();
}

Resumen de la validación en Rust básico

La esencia de la validación de una CLI consiste en comprobar un valor y comunicar un error claro. Este ejemplo lo muestra de principio a fin.

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

Comprobación rápida

Compruebe lo que ha aprendido sobre validación y ayuda.

Repaso

Ahora puede crear CLI pulidas:

value_parser impone rangos y reglas personalizadas
ValueEnum limita las opciones
conflicts_with modela indicadores incompatibles
Los comentarios de documentación se convierten en texto de ayuda
Devuelva Result desde main para los errores en tiempo de ejecución

Con esto termina el curso de clap.

Preguntas frecuentes

¿La lección «Validación y ayuda» es gratis?

Sí — el texto completo de «Validación y ayuda» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Validación y ayuda»?

CLIs pulidas Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Validación y ayuda»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding