Rust
Opdrachtregelargumenten

Invoering

Syntaxis

• gebruik std :: env; // Importeer de env-module
• let args = env :: args (); // Sla een Args-iterator op in de args-variabele.

Std :: env :: args () gebruiken

U kunt toegang krijgen tot de opdrachtregelargumenten die aan uw programma zijn doorgegeven met de functie std::env::args() . Dit retourneert een Args iterator die u kunt herhalen of verzamelen in een Vec .

Door argumenten heenkomen

use std::env;

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

Verzamelen in een Vec

use std::env;

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

Je zou meer argumenten kunnen krijgen dan je zou verwachten als je je programma zo noemt:

./example

Hoewel het lijkt alsof er geen argumenten zijn doorgegeven, is het eerste argument ( meestal ) de naam van het uitvoerbare bestand. Dit is echter geen garantie, dus je moet de argumenten die je krijgt altijd valideren en filteren.

Klap gebruiken

Voor grotere opdrachtregelprogramma's is het gebruik van std::env::args() vrij vervelend en moeilijk te beheren. U kunt clap gebruiken om uw opdrachtregelinterface af te handelen, die argumenten parseert, helpdisplays genereert en bugs voorkomt.

Er zijn verschillende patronen die u kunt gebruiken met clap , en elke patroon biedt een andere mate van flexibiliteit.

Bouwer patroon

Dit is de meest uitgebreide (en flexibele) methode, dus het is handig als u nauwkeurige controle over uw CLI nodig hebt.

clap onderscheid tussen subopdrachten en argumenten . Subopdrachten werken als onafhankelijke subprogramma's in je hoofdprogramma, net als cargo run en git push . Ze kunnen hun eigen opdrachtregelopties en ingangen hebben. Argumenten zijn eenvoudige vlaggen zoals --verbose , en ze kunnen invoer gebruiken (bijv. --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!");
    }
}