Learn Rust Coding · Lección

API derive

Args a partir de structs

API derive es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 3 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.

La API derive

La API derive permite describir su CLI como un struct y hacer que clap genere el analizador mediante #[derive(Parser)].

Menos código repetitivo que con la API de builder
Seguridad de tipos: los campos se convierten en valores tipados

Habilítela con la feature derive.

Un struct Parser mínimo

Anote un struct con #[derive(Parser)] y llame a Cli::parse() en main. Cada campo representa un argumento.

use clap::Parser;

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

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

El campo se convierte en posicional

Un campo simple como name: String es un argumento posicional obligatorio. El nombre del campo se convierte en su nombre de valor.

use clap::Parser;

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

Campos opcionales

Envuelva un campo en Option para hacerlo opcional. Si el usuario lo omite, obtendrá None.

use clap::Parser;

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

Flags y nombres cortos/largos

El atributo #[arg(short, long)] deriva -v y --verbose a partir del nombre del campo. Un campo bool se convierte en un interruptor.

use clap::Parser;

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

Valores tipados

clap analiza el valor según el tipo del campo. Un campo u32 rechaza automáticamente las entradas no numéricas.

use clap::Parser;

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

Modelar un Cli analizado

Una vez analizado, un struct Cli es simplemente un conjunto de datos. Esta versión ejecutable muestra cómo usaría los campos después del análisis.

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

Con la API derive, un enum #[derive(Subcommand)] representa los subcomandos. Cada variante es un comando.

use clap::{Parser, Subcommand};

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

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

Comparar subcomandos enum

Después de Cli::parse(), compare el enum para realizar el dispatch. Los datos de las variantes se desestructuran limpiamente.

use clap::Parser;

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

Metadatos mediante el atributo command

Coloque #[command(name, version, about)] en el struct para establecer los metadatos de la CLI. version puede obtenerse automáticamente de Cargo.

use clap::Parser;

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

Demostrar el dispatch de un enum

El patrón de comparar un enum es el núcleo de los subcomandos derive. Este es el mismo concepto en Rust autocontenido.

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

Comprobación rápida

Compruebe lo que ha aprendido sobre la API derive.

Repaso

La API derive convierte structs en analizadores:

#[derive(Parser)] junto con Cli::parse()
Los campos simples son posicionales; Option los hace opcionales
#[arg(short, long)] deriva flags y opciones
Los enums #[derive(Subcommand)] representan subcomandos

A continuación: validación y una salida de ayuda más cuidada.

Preguntas frecuentes

¿La lección «API derive» es gratis?

Sí — el texto completo de «API derive» 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 «API derive»?

Args a partir de structs 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 3 de 4.

¿Cuánto tiempo toma la lección «API derive»?

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