Argument parsing - Rust By Example
Description: Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries.

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# Argument parsing

Matching can be used to parse simple arguments:

    use std::env;

    fn increase(number: i32) {
        println!("{}", number + 1);
    }

    fn decrease(number: i32) {
        println!("{}", number - 1);
    }

    fn help() {
        println!("usage:
    match_args <string>
        Check whether given string is the answer.
    match_args {{increase|decrease}} <integer>
        Increase or decrease given integer by one.");
    }

    fn main() {
        let args: Vec<String> = env::args().collect();

        match args.len() {
            // no arguments passed
            1 => {
                println!("My name is 'match_args'. Try passing some arguments!");
            },
            // one argument passed
            2 => {
                match args[1].parse() {
                    Ok(42) => println!("This is the answer!"),
                    _ => println!("This is not the answer."),
                }
            },
            // one command and one argument passed
            3 => {
                let cmd = &args[1];
                let num = &args[2];
                // parse the number
                let number: i32 = match num.parse() {
                    Ok(n) => {
                        n
                    },
                    Err(_) => {
                        eprintln!("error: second argument not an integer");
                        help();
                        return;
                    },
                };
                // parse the command
                match &cmd[..] {
                    "increase" => increase(number),
                    "decrease" => decrease(number),
                    _ => {
                        eprintln!("error: invalid command");
                        help();
                    },
                }
            },
            // all the other cases
            _ => {
                // show a help message
                help();
            }
        }
    }

If you named your program `match_args.rs` and compile it like this `rustc match_args.rs`, you can execute it as follows:

    $ ./match_args Rust
    This is not the answer.
    $ ./match_args 42
    This is the answer!
    $ ./match_args do something
    error: second argument not an integer
    usage:
    match_args <string>
        Check whether given string is the answer.
    match_args {increase|decrease} <integer>
        Increase or decrease given integer by one.
    $ ./match_args do 42
    error: invalid command
    usage:
    match_args <string>
        Check whether given string is the answer.
    match_args {increase|decrease} <integer>
        Increase or decrease given integer by one.
    $ ./match_args increase 42
    43