Learn Rust Coding · Aula

Subcomandos

CLIs estruturadas

Subcomandos é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

O que são subcomandos?

Subcomandos permitem que um binário exponha várias ações, como git commit e git push.

Cada subcomando tem seus próprios argumentos
A estrutura acompanha o crescimento da sua CLI

clap modela isso com valores Command aninhados.

Adicionando um subcomando

Anexe um comando filho com .subcommand(). O comando pai se torna um despachante.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand(Command::new("add"))
        .subcommand(Command::new("list"))
        .get_matches();
}

Identificando o subcomando escolhido

Após a análise, subcommand() informa qual filho foi executado. Analise o nome dele para fazer o despacho.

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

Args dentro de um subcomando

Um subcomando contém seus próprios argumentos. O comando add abaixo recebe uma descrição de tarefa.

use clap::{Command, Arg};

fn main() {
    Command::new("todo")
        .subcommand(
            Command::new("add")
                .arg(Arg::new("task").required(true))
        )
        .get_matches();
}

Lendo os args do subcomando

O segundo elemento da tupla é o ArgMatches do subcomando. Extraia valores dele assim como faria no nível 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);
    }
}

Exigindo um subcomando

Use subcommand_required(true) para que executar o binário sem argumentos exiba a ajuda em vez de não fazer nada.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand_required(true)
        .arg_required_else_help(true)
        .subcommand(Command::new("list"))
        .get_matches();
}

Modelando o despacho em Rust puro

O núcleo de uma CLI com subcomandos é uma correspondência com uma string. Este exemplo executável reproduz essa lógica de despacho.

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 aninhados

Os subcomandos também podem ter subcomandos, por exemplo, cargo build --release e árvores mais profundas. Basta aninhar mais chamadas .subcommand().

use clap::Command;

fn main() {
    Command::new("app")
        .subcommand(
            Command::new("config")
                .subcommand(Command::new("get"))
                .subcommand(Command::new("set"))
        )
        .get_matches();
}

Ajuda por subcomando

Cada subcomando recebe sua própria página --help. Adicione uma string about para descrevê-lo.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand(
            Command::new("add").about("Add a new task")
        )
        .get_matches();
}

Aliases

Ofereça atalhos aos usuários com visible_alias. Agora ls funciona tanto quanto list.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand(
            Command::new("list").visible_alias("ls")
        )
        .get_matches();
}

Retornando códigos de saída

Uma CLI bem elaborada sinaliza sucesso ou falha. Retorne um código diferente de zero de um subcomando usando std::process::exit ou retornando Result de main.

fn main() {
    let success = true;
    if !success {
        std::process::exit(1);
    }
    println!("ok");
}

Verificação rápida

Teste sua compreensão dos subcomandos.

Recapitulação

Agora você cria CLIs estruturadas com subcomandos:

Adicione filhos com .subcommand()
Faça o despacho analisando m.subcommand()
Cada subcomando tem seus próprios args e página de ajuda
Use subcommand_required e aliases para aprimorar a CLI

A seguir: a API derive transforma structs em analisadores de argumentos.

Perguntas Frequentes

A aula “Subcomandos” é grátis?

Sim — o texto completo de “Subcomandos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Subcomandos”?

CLIs estruturadas Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Subcomandos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding