Rust
कमांड लाइन तर्क

परिचय

वाक्य - विन्यास

• उपयोग std :: env; // env मॉड्यूल आयात करें
• args = env :: args (); // Args वैरिएबल में एक Args पुनरावृत्ति स्टोर।

Std का प्रयोग :: env :: args ()

आप std::env::args() फ़ंक्शन का उपयोग करके अपने प्रोग्राम को दिए गए कमांड लाइन तर्कों का उपयोग कर सकते हैं। यह रिटर्न एक Args इटरेटर तुम पर या कलेक्ट एक में पाश कर सकते हैं जो Vec ।

तर्क के माध्यम से Iterating

use std::env;

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

एक Vec में एकत्रित करना

use std::env;

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

यदि आप अपने प्रोग्राम को इस तरह कहते हैं, तो आपको अपेक्षा से अधिक तर्क मिल सकते हैं:

./example

यद्यपि ऐसा लगता है कि कोई तर्क पारित नहीं किया गया था, पहला तर्क ( आमतौर पर ) निष्पादन योग्य का नाम है। हालांकि, इसकी कोई गारंटी नहीं है, इसलिए आपको हमेशा अपने द्वारा दिए गए तर्कों को मान्य और फ़िल्टर करना चाहिए।

ताली का उपयोग करना

बड़ी कमांड लाइन कार्यक्रमों के लिए, std::env::args() का उपयोग करना काफी थकाऊ और प्रबंधन करने में मुश्किल है। आप अपने कमांड लाइन इंटरफ़ेस को संभालने के लिए clap का उपयोग कर सकते हैं, जो तर्कों को पार्स करेगा, हेल्प डिस्प्ले प्रदर्शित करेगा और बग्स से बचाएगा।

कई पैटर्न हैं जो आप clap साथ उपयोग कर सकते हैं, और प्रत्येक एक अलग मात्रा में लचीलापन प्रदान करता है।

बिल्डर पैटर्न

यह सबसे क्रियात्मक (और लचीला) तरीका है, इसलिए यह तब उपयोगी होता है जब आपको अपने सीएलआई के ठीक-ठीक नियंत्रण की आवश्यकता होती है।

clap सबकॉमन्स और तर्कों के बीच अंतर करती है । Subcommands आपके मुख्य कार्यक्रम में cargo run और git push तरह स्वतंत्र उपप्रोग्राम की तरह काम करता है। उनके पास अपने स्वयं के कमांड-लाइन विकल्प और इनपुट हो सकते हैं। तर्क ऐसे सरल झंडे हैं जैसे कि --verbose , और वे इनपुट ले सकते हैं (उदाहरण --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!");
    }
}