Rust
Arguments de ligne de commande

Introduction

Syntaxe

• utilisez std :: env; // Importe le module env
• let args = env :: args (); // Stocker un itérateur Args dans la variable args.

Utiliser std :: env :: args ()

Vous pouvez accéder aux arguments de ligne de commande transmis à votre programme à l'aide de la fonction std::env::args() . Cela retourne un itérateur Args que vous pouvez Args boucle ou collecter dans un Vec .

Itérer à travers les arguments

use std::env;

fn main() {
    for argument in env::args() {
        if argument == "--help" {
            println!("You passed --help as one of the arguments!");
        }
    }
}

Collecter dans un Vec

use std::env;

fn main() {
    let arguments: Vec<String> = env::args().collect();
    println!("{} arguments passed", arguments.len());
}

Vous pourriez obtenir plus d'arguments que prévu si vous appelez votre programme comme ceci:

./example

Bien qu'il semble que aucun argument n'ait été transmis, le premier argument est ( généralement ) le nom de l'exécutable. Ce n'est pas une garantie, donc vous devez toujours valider et filtrer les arguments que vous obtenez.

En utilisant clap

Pour les programmes en ligne de commande plus importants, l'utilisation de std::env::args() est assez fastidieuse et difficile à gérer. Vous pouvez utiliser clap pour gérer votre interface de ligne de commande, qui analysera les arguments, générera des affichages d'aide et évitera les bogues.

Il existe plusieurs modèles que vous pouvez utiliser avec clap , et chacun fournit une quantité de flexibilité différente.

Motif de constructeur

C'est la méthode la plus prolixe (et la plus flexible), elle est donc utile lorsque vous avez besoin d'un contrôle précis de votre interface de ligne de commande.

clap distingue les sous - commandes et les arguments . Les sous-commandes agissent comme des sous-programmes indépendants dans votre programme principal, tout comme les opérations de cargo run et de git push . Ils peuvent avoir leurs propres options et entrées de ligne de commande. Les arguments sont des indicateurs simples tels que --verbose , et ils peuvent prendre des entrées (par exemple --message "Hello, world" )

extern crate clap;
use clap::{Arg, App, SubCommand};

fn main() {
    let app = App::new("Foo Server")
        .about("Serves foos to the world!")
        .version("v0.1.0")
        .author("Foo (@Example on GitHub)")
        .subcommand(SubCommand::with_name("run")
            .about("Runs the Foo Server")
            .arg(Arg::with_name("debug")
                .short("D")
                .about("Sends debug foos instead of normal foos.")))

    // This parses the command-line arguments for use.
    let matches = app.get_matches();

    // We can get the subcommand used with matches.subcommand(), which
    // returns a tuple of (&str, Option<ArgMatches>) where the &str
    // is the name of the subcommand, and the ArgMatches is an 
    // ArgMatches struct: 
    // https://docs.rs/clap/2.13.0/clap/struct.ArgMatches.html

    if let ("run", Some(run_matches)) = app.subcommand() {
        println!("Run was used!");
    }
}