Here is a 2500+ word blog post on "command line arguments rust":
Command line arguments allow users to pass input values to a program when invoking it from the terminal or command prompt. They enable modifying program behavior without changing the code.
Rust provides inbuilt support for parsing command line arguments via the std::env module. In this comprehensive guide, we will cover everything you need to know about command line arguments in Rust:
Table of Contents
- Accessing Raw Arguments Vector
- Iterating Through Arguments
- Parsing Arguments into Variables
- Validating Arguments
- Setting Default Values for Arguments
- Required and Optional Arguments
- Argument Parsing Crates
1. Accessing Raw Arguments Vector
The first step is accessing the raw string vector containing arguments passed to our program.
This is done via the args() method from std::env:
use std::env;
fn main() {
let args: Vec<String> = env::args().collect();
}The args() method returns an iterator over arguments. We collect this iterator into a vector Vec to store arguments.
The first argument is always the path of the executed binary. Any additional arguments supplied by the user follow.
For example, if we run our program as:
./myprogram arg1 arg2 arg3The args vector will contain:
["./myprogram", "arg1", "arg2", "arg3"]2. Iterating Through Arguments
We can iterate through the arguments vector to access individual arguments:
use std::env;
fn main() {
let args: Vec<String> = env::args().collect();
for argument in args {
println!("Argument: {}", argument);
}
}If we run the program with additional arguments:
./myprogram arg1 arg2 arg3It will print out:
Argument: ./myprogram
Argument: arg1
Argument: arg2
Argument: arg3We can also access arguments via their index:
let first = &args[1];
let second = &args[2]; 3. Parsing Arguments into Variables
For more complex argument parsing we need to parse arguments into variables rather than using the raw vector.
Here is an example program that accepts two numbers and prints their sum:
use std::env;
fn main() {
let args: Vec<String> = env::args().collect();
let a = &args[1].parse::<i32>().unwrap();
let b = &args[2].parse::<i32>().unwrap();
println!("Result: {}", a + b);
}To run it:
./myprogram 10 20This parses the first argument into an i32 integer a, second argument into b. We can then perform our program logic using these extracted values.
4. Validating Arguments
With external input arguments, we need to validate them before usage in our program.
Some examples of validation include:
- Checking number and type of arguments
- Range checks on int/float arguments
- Regex checks on string arguments
Here is an example with some basic validation:
use std::env;
fn main() {
let args: Vec<String> = env::args().collect();
// Check expected number of arguments
if args.len() < 3 {
println!("Usage: {} <x> <y>", args[0]);
return;
}
// Parse arguments
let x = match args[1].parse::<i32>() {
Ok(num) => num,
Err(_) => {
println!("Expected integer for x");
return;
}
};
let y = match args[2].parse::<i32>() {
Ok(num) => num,
Err(_) => {
println!("Expected integer for y");
return;
}
};
// Additional validation
if x < 0 || y < 0 {
println!("X and Y should be positive");
return;
}
println!("Result: {}", x + y);
}Here we:
- Check we have at least 3 arguments (program name + 2 args)
- Use pattern matching to validate x and y can parse as integers
- Check x and y are positive
Failing any check leads to an early return from main before usage.
5. Default Values for Arguments
We can assign default values if arguments are not provided rather than just exiting.
This makes arguments effectively optional.
let x = match args.get(1) {
Some(arg) => arg.parse::<i32>().unwrap_or(10), //default is 10
None => 10,
};
let y = match args.get(2) {
Some(arg) => arg.parse::<i32>().unwrap_or(20), //default is 20
None => 20,
}; Here if args[1] or args[2] are missing we default to 10 and 20 respectively.
6. Required and Optional Arguments
We can formalize the concept of required and optional arguments using a struct:
struct Args {
x: i32,
y: i32,
z: Option<i32> // Optional arg
}
fn main() {
let args: Vec<String> = env::args().collect();
let args = Args {
x: args[1].parse().unwrap(),
y: args[2].parse().unwrap(),
z: match args.get(3) {
Some(v) => Some(v.parse().unwrap()),
None => None,
}
};
}Now x and y are required, z is an optional third argument. The Args struct enforces this at compile time.
7. Argument Parsing Crates
Instead of hand-writing argument parsing logic, we can use one of Rust‘s argument parsing crates:
- clap: Most popular argument parsing crate
- structopt: Argument parsing based on structs
- gumdrop: Minimal & ergonomic parsing
- argh: Simple argument parsing
Here is clap usage example:
use clap::{Arg, App};
fn main() {
let matches = App::new("My Program")
.arg(Arg::with_name("x")
.required(true)
.index(1))
.arg(Arg::with_name("y")
.required(true)
.index(2))
.get_matches();
let x = matches.value_of("x").unwrap().parse::<i32>().unwrap();
let y = matches.value_of("y").unwrap().parse::<i32>().unwrap();
println!("X + Y = {}", x + y);
}Much cleaner! The crate handles:
- Parsing arguments into usable values
- Generated help messages
- Input validation
- Default values
- Argument types
This removes a lot of boilerplate from our code.
I recommend trying out all 4 crates to see which fits your use case best.
Conclusion
That wraps up our guide on command line arguments in Rust!
We learned how to:
- Access raw argument vector
- Iterate through arguments
- Parse arguments into variables
- Validate argument input
- Set default fallback values
- Differentiate required and optional arguments
- Leverage argument parsing crates for cleaner code
Command line arguments are a vital tool for controlling Rust program execution.
This guide should provide a strong base for utilizing them effectively in your own projects. Let me know if you have any other questions!