Subcomandos
CLIs estructuradas
Subcomandos es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 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.
¿Qué son los subcomandos?
Los subcomandos permiten que un mismo binario exponga varias acciones, como git commit y git push.
- Cada subcomando tiene sus propios argumentos
- La estructura se adapta al crecimiento de su CLI
clap los representa mediante valores Command anidados.
Añadir un subcomando
Asocie un comando hijo con .subcommand(). El padre se convierte en un dispatcher.
use clap::Command;
fn main() {
Command::new("todo")
.subcommand(Command::new("add"))
.subcommand(Command::new("list"))
.get_matches();
}Identificar el subcomando elegido
Después del análisis, subcommand() indica qué hijo se ejecutó. Compare su nombre para realizar el dispatch.
use clap::Command;
fn main() {
let m = Command::new("todo")
.subcommand(Command::new("add"))
.subcommand(Command::new("list"))
.get_matches();
match m.subcommand() {
Some(("add", _)) => println!("adding"),
Some(("list", _)) => println!("listing"),
_ => println!("no subcommand"),
}
}Argumentos dentro de un subcomando
Un subcomando contiene sus propios argumentos. El comando add de abajo recibe una descripción de tarea.
use clap::{Command, Arg};
fn main() {
Command::new("todo")
.subcommand(
Command::new("add")
.arg(Arg::new("task").required(true))
)
.get_matches();
}Leer los argumentos del subcomando
El segundo elemento de la tupla es el ArgMatches del subcomando. Extraiga valores de él igual que en el nivel superior.
use clap::{Command, Arg};
fn main() {
let m = Command::new("todo")
.subcommand(Command::new("add").arg(Arg::new("task")))
.get_matches();
if let Some(("add", sub)) = m.subcommand() {
let task = sub.get_one::<String>("task").unwrap();
println!("add: {}", task);
}
}Exigir un subcomando
Use subcommand_required(true) para que ejecutar el binario sin argumentos muestre la ayuda en lugar de no hacer nada.
use clap::Command;
fn main() {
Command::new("todo")
.subcommand_required(true)
.arg_required_else_help(true)
.subcommand(Command::new("list"))
.get_matches();
}Modelar el dispatch con Rust básico
El núcleo de una CLI con subcomandos es un match sobre una cadena. Este ejemplo ejecutable reproduce esa lógica de dispatch.
fn main() {
let cmd = "add";
let task = "Buy milk";
match cmd {
"add" => println!("Added: {}", task),
"list" => println!("Listing tasks"),
other => println!("Unknown command: {}", other),
}
}Subcomandos anidados
Los subcomandos pueden tener sus propios subcomandos, por ejemplo, cargo build --release frente a árboles más profundos. Solo tiene que anidar más llamadas a .subcommand().
use clap::Command;
fn main() {
Command::new("app")
.subcommand(
Command::new("config")
.subcommand(Command::new("get"))
.subcommand(Command::new("set"))
)
.get_matches();
}Ayuda para cada subcomando
Cada subcomando obtiene su propia página de --help. Añada una cadena about para describirlo.
use clap::Command;
fn main() {
Command::new("todo")
.subcommand(
Command::new("add").about("Add a new task")
)
.get_matches();
}Alias
Proporcione atajos a los usuarios con visible_alias. Ahora ls funciona igual que list.
use clap::Command;
fn main() {
Command::new("todo")
.subcommand(
Command::new("list").visible_alias("ls")
)
.get_matches();
}Devolver códigos de salida
Una CLI bien diseñada indica si la operación tuvo éxito o falló. Devuelva un código distinto de cero desde un subcomando usando std::process::exit o devolviendo Result desde main.
fn main() {
let success = true;
if !success {
std::process::exit(1);
}
println!("ok");
}Comprobación rápida
Compruebe lo que ha aprendido sobre los subcomandos.
Repaso
Ahora puede crear CLI estructuradas con subcomandos:
- Añada comandos hijos con
.subcommand() - Realice el dispatch comparando
m.subcommand() - Cada subcomando tiene sus propios argumentos y página de ayuda
- Use
subcommand_requiredy alias para perfeccionar la CLI
A continuación: la API derive convierte structs en analizadores de argumentos.
Preguntas frecuentes
¿La lección «Subcomandos» es gratis?
Sí — el texto completo de «Subcomandos» 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 «Subcomandos»?
CLIs estructuradas 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 2 de 4.
¿Cuánto tiempo toma la lección «Subcomandos»?
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.