Learn Rust Coding · Leçon

Sous-commandes

CLI structurées

Sous-commandes est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 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.

Que sont les sous-commandes ?

Les sous-commandes permettent à un binaire d’exposer plusieurs actions, comme git commit et git push.

Chaque sous-commande possède ses propres arguments
La structure évolue avec votre CLI

clap les représente avec des valeurs Command imbriquées.

Ajouter une sous-commande

Ajoutez une commande enfant avec .subcommand(). Le parent devient un répartiteur.

use clap::Command;

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

Faire correspondre la sous-commande choisie

Après l’analyse, subcommand() vous indique quel enfant a été exécuté. Faites correspondre son nom pour effectuer la répartition.

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

Arguments dans une sous-commande

Une sous-commande possède ses propres arguments. La commande add ci-dessous accepte la description d’une tâche.

use clap::{Command, Arg};

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

Lire les arguments d’une sous-commande

Le deuxième élément du tuple est le ArgMatches de la sous-commande. Récupérez-y les valeurs comme au niveau supérieur.

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

Exiger une sous-commande

Utilisez subcommand_required(true) afin que l’exécution du binaire seul affiche l’aide au lieu de ne rien faire.

use clap::Command;

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

Modéliser la répartition en Rust simple

Le cœur d’un CLI à sous-commandes est une correspondance sur une chaîne. Cet exemple exécutable reproduit cette logique de répartition.

fn main() {
    let cmd = "add";
    let task = "Buy milk";
    match cmd {
        "add" => println!("Added: {}", task),
        "list" => println!("Listing tasks"),
        other => println!("Unknown command: {}", other),
    }
}

Sous-commandes imbriquées

Les sous-commandes peuvent elles-mêmes posséder des sous-commandes, par exemple cargo build --release, avec des arborescences plus profondes. Il suffit d’imbriquer davantage d’appels à .subcommand().

use clap::Command;

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

Aide propre à chaque sous-commande

Chaque sous-commande possède sa propre page --help. Ajoutez une chaîne about pour la décrire.

use clap::Command;

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

Alias

Proposez des raccourcis aux utilisateurs avec visible_alias. Désormais, ls fonctionne aussi bien que list.

use clap::Command;

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

Renvoyer des codes de sortie

Un CLI soigné signale la réussite ou l’échec. Renvoyez un code différent de zéro depuis une sous-commande avec std::process::exit, ou renvoyez Result depuis main.

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

Vérification rapide

Vérifiez votre compréhension des sous-commandes.

Récapitulatif

Vous pouvez maintenant créer des CLI structurés avec des sous-commandes :

Ajoutez des enfants avec .subcommand()
Effectuez la répartition en faisant correspondre m.subcommand()
Chaque sous-commande possède ses propres arguments et sa page d’aide
Utilisez subcommand_required et des alias pour peaufiner votre CLI

Ensuite : l’interface derive transforme les structures en analyseurs d’arguments.

Questions Fréquemment Posées

La leçon « Sous-commandes » est-elle gratuite ?

Oui — le texte complet de « Sous-commandes » 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 « Sous-commandes » ?

CLI structuré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 2 sur 4.

Combien de temps prend la leçon « Sous-commandes » ?

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