명령 줄 매개 변수에 액세스하는 방법은 무엇입니까?

Question

Rust tutorial은 명령 줄에서 매개 변수를 가져 오는 방법을 설명하지 않습니다. fn main()은 모든 예제에서 빈 매개 변수 목록과 함께 표시됩니다.

main에서 명령 줄 매개 변수에 액세스하는 올바른 방법은 무엇입니까?

Answer 1

std::env::args 또는 std::env::args_os 기능을 사용하여 명령 줄 인수에 액세스 할 수 있습니다. 두 함수 모두 인수에 대한 반복자를 리턴합니다. 전자는 String (작업하기 쉽습니다)을 반복하지만 인수 중 하나가 유효한 유니 코드가 아닌 경우 패닉이 발생합니다. 후자는 OsString 초 이상으로 반복되며 패닉이 발생하지 않습니다.

반복자의 첫 번째 요소는 프로그램 자체의 이름입니다 (모든 주요 OS에서 규칙입니다). 따라서 첫 번째 인수는 실제로 두 번째 반복 요소입니다. args의 결과를 다루는

쉬운 방법은 Vec로 변환하는 것입니다

use std::env; 

fn main() { 
    let args: Vec<_> = env::args().collect(); 
    if args.len() > 1 { 
     println!("The first argument is {}", args[1]); 
    } 
} 

당신은 이러한 인수 작업을 전체 standard iterator toolbox를 사용할 수 있습니다.

• docopt : 당신은 명령 줄 인수를 구문 분석 crates.io에 라이브러리를 찾을 수 있습니다

  use std::env; 
  
  fn main() { 
      if let Some(arg1) = env::args().nth(1) { 
       println!("The first argument is {}", arg1); 
      } 
  } 
  

  예를 들어, 첫 번째 인수를 검색하기 위해 당신은 단지 도움말 메시지를 작성하고, 구문 분석 코드가 생성됩니다 너를 위해서.

• clap : 유창한 API를 사용하여 구문 분석하려는 옵션을 설명합니다. docopt보다 빠르며 제어력이 향상됩니다.
• getopts : 인기있는 C 라이브러리의 포트. 낮은 수준의 제어.

Answer 2

무엇 @barjak 말했다 문자열에 대한 작동하지만 당신은 당신이 이런 식으로 변환해야합니다 (이 경우에는 UINT)를 숫자로 인수를 필요로하는 경우 :

fn main() { 
    let arg : ~[~str] = os::args(); 
    match uint::from_str(arg[1]){ 
     Some(x)=>io::println(fmt!("%u",someFunction(x))), 
     None=>io::println("I need a real number") 
    } 
} 

Answer 3

녹 getopt는 스타일의 CLI가 있습니다 인수 구문 분석은 getopts module에 있습니다. 버전 0.8/0.9로

Answer 4

, 함수 인수에 대한 올바른 경로() ::std::os::args 것, 즉 :

fn main() { 
    let args: ~[~str] = ::std::os::args(); 
    println(args[0]); 
} 

이 녹 심지어 표준 IO와 지금 여전히 매우 휘발성 것 같다, 그래서이 상당히 빨리 구식이 될 수 있습니다.

Answer 5

최신 Rust 버전 (Rust> 0.10/11)에서는 배열 구문이 작동하지 않습니다. get 메소드를 사용해야합니다.

[편집] 배열 구문은 야간에 (다시) 작동합니다. 따라서 getter 또는 배열 인덱스 중에서 선택할 수 있습니다.

use std::os; 

fn main() { 
    let args = os::args(); 
    println!("{}", args.get(1)); 
} 

// Compile 
rustc args.rs && ./args hello-world // returns hello-world 

Answer 6

녹슬은 2013 년 5 월 이후의 칼빈의 대답부터 발전했습니다.이제 하나는 as_slice()으로 명령 줄 인수를 구문 분석 :

use std::os; 

fn seen_arg(x: uint) 
{  
    println!("you passed me {}", x); 
} 
fn main() { 
    let args = os::args(); 
    let args = args.as_slice(); 
    let nitems = { 
      if args.len() == 2 { 
        from_str::<uint>(args[1].as_slice()).unwrap() 
      } else { 
        10000 
      } 
    }; 

    seen_arg(nitems); 
} 

Answer 7

Docopt는 사용 문자열에서 당신을 위해 파서를 생성 녹,도 사용할 수 있습니다. 녹에 보너스로, 매크로가 자동으로 구조체를 생성하고 유형을 기반 디코딩을 수행하는 데 사용할 수 있습니다

docopt!(Args, " 
Usage: cp [-a] SOURCE DEST 
     cp [-a] SOURCE... DIR 

Options: 
    -a, --archive Copy everything. 
") 

을 그리고 당신과 함께 인수를 얻을 수 있습니다 :

let args: Args = Args::docopt().decode().unwrap_or_else(|e| e.exit()); 

추가 정보 및 documentation 많음이있다 전체 작동 예제.

면책 조항 : 본인은이 라이브러리의 저자입니다.

Answer 8

Rust book "No stdlib" chapter은 명령 줄 매개 변수에 액세스하는 방법 (다른 방법)을 설명합니다.

// Entry point for this program 
#[start] 
fn start(_argc: isize, _argv: *const *const u8) -> isize { 
    0 
} 

이제, 예를 또한 내가 일반적으로 표준 라이브러리 바이너리에 대한 진정한 진입 점을 가지고 main()라는 전역 함수를 호출 할 방법을 생각 #![no_std]을 가지고있다. 또 다른 옵션은 'main shim'을 #![no_main]으로 사용 중지하는 것입니다. 나는 컴파일러에게 프로그램 시작 방법을 완전히 제어하고 있다고 잘못 말하면 안됩니다.

#![no_std] 
#![no_main] 

#[no_mangle] // ensure that this symbol is called `main` in the output 
pub extern fn main(argc: isize, argv: *const *const u8) -> isize { 
    0 
} 

---

나는 이것이 당신이 원하는 모든 명령 줄 인수를 읽을 경우 일을하는 '좋은'방법이라고 생각하지 않습니다. 다른 대답에 언급 된 std::os 모듈은 일을하는 훨씬 더 좋은 방법 인 것 같습니다. 나는이 답변을 완성을 위해 게시합니다.

Answer 9

녹슬림이 다시 변경되었습니다. os::args()은 (는) std::args()으로 대체됩니다. 그러나 std::args()은 배열이 아니므로 반복자을 반환합니다. 명령 행 인수를 반복 할 수는 있지만 첨자를 사용하여 액세스 할 수는 없습니다. 당신은 문자열의 벡터로 명령 줄 인수를 원하는 경우

http://doc.rust-lang.org/std/env/fn.args.html

이 이제 작동합니다

use std::env; 
... 
let args: Vec<String> = env::args().map(|s| s.into_string().unwrap()).collect(); 

녹 - 변화의 고통을 포용하는 법을 배워야.

Answer 10

나를 위해, getopts는 항상 너무 낮은 수준이었고 docopt.rs는 너무 많은 마법이었습니다. 내가 원하는 경우 모든 기능을 제공하는 명확하고 직관적 인 무언가가 필요합니다.

여기는 clap-rs이 유용합니다.
Python의 argparse와 조금 비슷합니다.또한 structopt을 확인

println!("Using input file: {}", matches.value_of("INPUT").unwrap()); 

// Gets a value for config if supplied by user, or defaults to "default.conf" 
let config = matches.value_of("CONFIG").unwrap_or("default.conf"); 
println!("Value for config: {}", config); 

이

Answer 11

합니다 (official documentation에서 복사) : 당신은 너무처럼 매개 변수에 액세스 할 수 있습니다

let matches = App::new("myapp") 
         .version("1.0") 
         .author("Kevin K. <kbknapp@gmail.com>") 
         .about("Does awesome things") 
         .arg(Arg::with_name("CONFIG") 
          .short("c") 
          .long("config") 
          .help("Sets a custom config file") 
          .takes_value(true)) 
         .arg(Arg::with_name("INPUT") 
          .help("Sets the input file to use") 
          .required(true) 
          .index(1)) 
         .arg(Arg::with_name("debug") 
          .short("d") 
          .multiple(true) 
          .help("Sets the level of debugging information")) 
         .get_matches(); 

: 여기가 보이는 방법의 예입니다

extern crate structopt; 
#[macro_use] 
extern crate structopt_derive; 

use structopt::StructOpt; 

#[derive(StructOpt, Debug)] 
#[structopt(name = "example", about = "An example of StructOpt usage.")] 
struct Opt { 
    /// A flag, true if used in the command line. 
    #[structopt(short = "d", long = "debug", help = "Activate debug mode")] 
    debug: bool, 

    /// An argument of type float, with a default value. 
    #[structopt(short = "s", long = "speed", help = "Set speed", default_value = "42")] 
    speed: f64, 

    /// Needed parameter, the first on the command line. 
    #[structopt(help = "Input file")] 
    input: String, 

    /// An optional parameter, will be `None` if not present on the 
    /// command line. 
    #[structopt(help = "Output file, stdout if not present")] 
    output: Option<String>, 
} 

fn main() { 
    let opt = Opt::from_args(); 
    println!("{:?}", opt); 
} 

https://github.com/TeXitoi/structopt