Learn Rust Coding · Leçon

Bases de clap

Analyse des arguments

Bases de clap est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 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.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Why clap?

clap (Command Line Argument Parser) is the de-facto standard crate for building CLIs in Rust.

Parses arguments, flags, and options
Generates --help and --version automatically
Validates input and reports friendly errors

Without it you would manually iterate over std::env::args() and handle every edge case yourself.

Reading args by hand

Before reaching for clap, it helps to see the raw approach. std::env::args() yields an iterator where the first item is the program name.

fn main() {
    let args: Vec<String> = std::env::args().collect();
    println!("Program: {}", args[0]);
    println!("Got {} extra arg(s)", args.len() - 1);
}

Adding clap to Cargo.toml

To use clap you declare it as a dependency. The derive feature unlocks the macro-based API.

cargo add clap --features derive

This step runs in your terminal and edits your project files, so it is not something we execute here.

[dependencies]
clap = { version = "4", features = ["derive"] }

The builder API

clap has two styles. The builder API constructs a Command at runtime by chaining method calls.

use clap::{Command, Arg};

fn main() {
    let cmd = Command::new("greet")
        .arg(Arg::new("name"));
    let matches = cmd.get_matches();
    // access values from matches
}

Positional arguments

A positional argument is supplied by order, not by a flag. Here name is read directly from the command line.

greet Alice sets name to Alice

use clap::{Command, Arg};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("name").required(true))
        .get_matches();
    let name = m.get_one::<String>("name").unwrap();
    println!("Hello, {}!", name);
}

Optional flags

A flag is a boolean switch. Use ArgAction::SetTrue so its presence flips a bool.

--loud turns the flag on

use clap::{Command, Arg, ArgAction};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("loud").long("loud").action(ArgAction::SetTrue))
        .get_matches();
    let loud = m.get_flag("loud");
    println!("loud = {}", loud);
}

Options with values

An option takes a value, like --count 3. Give it a short and a long name for ergonomics.

use clap::{Command, Arg};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("count").short('c').long("count"))
        .get_matches();
    if let Some(c) = m.get_one::<String>("count") {
        println!("count = {}", c);
    }
}

Default values

Give an argument a fallback with default_value so users can omit it.

If --count is missing, it becomes 1

use clap::{Command, Arg};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("count").long("count").default_value("1"))
        .get_matches();
    let count = m.get_one::<String>("count").unwrap();
    println!("count = {}", count);
}

Simulating the result

Even without clap installed we can model what the parsed values look like. Here is a plain-Rust stand-in showing the logic clap performs for us.

fn main() {
    let name = "Alice";
    let count: u32 = 3;
    for _ in 0..count {
        println!("Hello, {}!", name);
    }
}

Auto-generated help

clap builds --help for free from your argument metadata. Add about and help strings to make it useful.

use clap::{Command, Arg};

fn main() {
    Command::new("greet")
        .about("Greets a person")
        .arg(Arg::new("name").help("Who to greet"))
        .get_matches();
}

Version flag

Set a version once and clap wires up --version. The crate_version! macro pulls it from Cargo.toml.

use clap::Command;

fn main() {
    Command::new("greet")
        .version("1.0.0")
        .get_matches();
}

Quick Check

Test your understanding of clap basics.

Recap

You learned the foundations of clap:

Add it with the derive feature
The builder API uses Command and Arg
Positionals are ordered; flags use SetTrue; options take values
default_value provides fallbacks
--help and --version are generated automatically

Next you will structure larger CLIs with subcommands.

Questions Fréquemment Posées

La leçon « Bases de clap » est-elle gratuite ?

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

Analyse des arguments 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 1 sur 4.

Combien de temps prend la leçon « Bases de clap » ?

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