Rust
Argomenti della riga di comando

introduzione

Sintassi

• usa std :: env; // Importa il modulo env
• let args = env :: args (); // Archivia un iteratore Args nella variabile args.

Utilizzando std :: env :: args ()

È possibile accedere agli argomenti della riga di comando passati al programma utilizzando la funzione std::env::args() . Questo restituisce un iteratore Args che puoi ricopiare o raccogliere in un 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!");
        }
    }
}

Collezionando in un Vec

use std::env;

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

Potresti ottenere più argomenti del previsto se chiami il tuo programma in questo modo:

./example

Anche se sembra che non siano stati passati argomenti, il primo argomento è (di solito ) il nome dell'eseguibile. Questa non è una garanzia, quindi devi sempre convalidare e filtrare gli argomenti che ottieni.

Usando clap

Per programmi di riga di comando più grandi, l'uso di std::env::args() è piuttosto noioso e difficile da gestire. È possibile utilizzare clap per gestire l'interfaccia della riga di comando, che analizzerà gli argomenti, genererà visualizzazioni di guida ed eviterà bug.

Esistono diversi pattern che è possibile utilizzare con clap e ognuno offre una diversa flessibilità.

Modello costruttore

Questo è il metodo più dettagliato (e flessibile), quindi è utile quando hai bisogno di un controllo preciso della tua CLI.

clap distingue tra sottocomandi e argomenti . I sottocomandi si comportano come sottoprogrammi indipendenti nel programma principale, proprio come la cargo run e il git push . Possono avere le proprie opzioni e input della riga di comando. Gli argomenti sono semplici flag come --verbose e possono prendere input (es. --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!");
    }
}