Rust
Kommandoradsargument

Introduktion

Syntax

• använd std :: env; // Importera env-modulen
• låt args = env :: args (); // Spara en Args-iterator i args-variabeln.

Använda std :: env :: args ()

Du kan komma åt kommandoradsargumenten som skickas till ditt program med funktionen std::env::args() . Detta returnerar en Args iterator som du kan slinga över eller samla in i en Vec .

Iterating Through Arguments

use std::env;

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

Samla in i en Vec

use std::env;

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

Du kan få fler argument än du förväntar dig om du ringer ditt program så här:

./example

Även om det ser ut som att inga argument överfördes är det första argumentet ( vanligtvis ) namnet på den körbara. Detta är dock ingen garanti, så du bör alltid validera och filtrera de argument du får.

Med klapp

För större kommandoradsprogram är användning av std::env::args() ganska tråkigt och svårt att hantera. Du kan använda clap att hantera ditt kommandoradsgränssnitt, som kommer att analysera argument, generera hjälpskärmar och undvika buggar.

Det finns flera mönster som du kan använda med clap , och var och en ger en annan mängd flexibilitet.

Builder mönster

Detta är den mest fullständiga (och flexibla) metoden, så den är användbar när du behöver finkornig kontroll av din CLI.

clap skiljer mellan subkommandon och argument . Underkommandon fungerar som oberoende underprogram i ditt huvudprogram, precis som cargo run och git push . De kan ha sina egna kommandoradsalternativ och ingångar. Argument är enkla flaggor som - --verbose , och de kan ta input (t.ex. - --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!");
    }
}