Rust
Kommandozeilenargumente

Einführung

Syntax

• Verwenden Sie std :: env; // Importiere das env-Modul
• lassen Sie args = env :: args (); // Einen Args-Iterator in der args-Variablen speichern.

Std :: env :: args () verwenden

Sie können auf die Befehlszeilenargumente zugreifen, die mit der Funktion std::env::args() an Ihr Programm übergeben werden. Dies gibt einen Args Iterator zurück, den Sie Args oder in einem Vec sammeln können.

Durch Argumente iterieren

use std::env;

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

Sammeln in ein Vec

use std::env;

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

Wenn Sie Ihr Programm so aufrufen, erhalten Sie möglicherweise mehr Argumente als erwartet:

./example

Obwohl es so aussieht, als ob keine Argumente übergeben wurden, ist das erste Argument ( normalerweise ) der Name der ausführbaren Datei. Dies ist jedoch keine Garantie, daher sollten Sie die Argumente, die Sie erhalten, immer überprüfen und filtern.

Mit klatschen

Bei größeren Befehlszeilenprogrammen ist die Verwendung von std::env::args() ziemlich langwierig und schwer zu verwalten. Sie können clap , um Ihre Befehlszeilenschnittstelle zu handhaben, die Argumente analysiert, Hilfedisplays generiert und Fehler vermeidet.

Es gibt mehrere Muster , die Sie mit clap , und jedes bietet unterschiedliche Flexibilität.

Generator-Muster

Dies ist die ausführlichste (und flexibelste) Methode. Sie ist daher nützlich, wenn Sie eine genaue Kontrolle Ihrer CLI benötigen.

clap unterscheidet zwischen Unterbefehlen und Argumenten . Unterbefehle verhalten sich wie unabhängige Unterprogramme in Ihrem Hauptprogramm, genau wie cargo run und git push . Sie können eigene Befehlszeilenoptionen und -eingaben haben. Argumente sind einfache Flags wie --verbose , und sie können Eingaben annehmen (zB --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!");
    }
}