命令行参数输入
我们创建一个grep工具，玩过Linux中grep的同学应该很清楚是有什么作用的。我们给它取名叫minigrep，先创建一个可执行项目：
$ cargo new minigrep
Created binary (application) `minigrep` project
$ cd minigrep
要从命令行来接收参数，我们需要标准库std::env::args函数，这个函数会返回一个命令行参数迭代。看例子：
use std::env;
fn main() {
let args: Vec<String> = env::args().collect();
println!("{:?}", args);
}
当我们执行cargo run并且带上参数，会看到下面的信息：
$ cargo run needle haystack
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 1.57s
Running `target/debug/minigrep needle haystack`
["target/debug/minigrep", "needle", "haystack"]
这个数组，第一个元素是可运行文件本身，后面才是参数。现在我们设想，需要实现的minigrep工具接收两个参数，第一个是需要查询的关键字，第二个是文件名，那么我们把代码改成这样：
use std::env;
fn main() {
let args: Vec<String> = env::args().collect();
let query = &args[1];
let filename = &args[2];
println!("Searching for {}", query);
println!("In file {}", filename);
}
当然，我们收到了参数后没有进行实际的操作，暂时只做了打印。
文件读写
现在我们学一下文件读写，以便完成在文件中查询关键字这个命令行工具。我们首先创建一个文件poem.txt，在里面写一首诗：
I'm nobody! Who are you?
Are you nobody, too?
Then there's a pair of us - don't tell!
They'd banish us, you know.
How dreary to be somebody!
How public, like a frog
To tell your name the livelong day
To an admiring bog!
现在我们在前面的代码基础上，加一段读文件的操作：
use std::env;
use std::fs;
fn main() {
// --snip--
println!("In file {}", filename);
let contents = fs::read_to_string(filename)
.expect("Something went wrong reading the file");
println!("With text:\n{}", contents);
}
看看输出：
$ cargo run the poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep the poem.txt`
Searching for the
In file poem.txt
With text:
I'm nobody! Who are you?
Are you nobody, too?
Then there's a pair of us - don't tell!
They'd banish us, you know.
How dreary to be somebody!
How public, like a frog
To tell your name the livelong day
To an admiring bog!
重构代码
我们在main中实现了两个功能，一个是解析命令行参数，一个是读文件。如果是一个小项目，功能简单，这倒也没什么。如果是做一个大项目，还是要有明确的功能划分。
我们需要把参数解析和文件处理放到lib.rs中去，而main中只保留调用lib，以及异常处理的逻辑。
我们一步一步来拆解，首先来把参数解析提取出来：
fn main() {
let args: Vec<String> = env::args().collect();
let (query, filename) = parse_config(&args);
// --snip--
}
fn parse_config(args: &[String]) -> (&str, &str) {
let query = &args[1];
let filename = &args[2];
(query, filename)
}
不过这两个参数放在外面也有些难看，如果参数更多呢？现在两个还好，如果五六个就不好看了。我们可以把参数放到一个struct里面：
fn main() {
let args: Vec<String> = env::args().collect();
let config = parse_config(&args);
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
let contents = fs::read_to_string(config.filename)
.expect("Something went wrong reading the file");
// --snip--
}
struct Config {
query: String,
filename: String,
}
fn parse_config(args: &[String]) -> Config {
let query = args[1].clone();
let filename = args[2].clone();
Config { query, filename }
}
不过这么些struct，显得有点孤立，我们可以把parse_config函数改成Config的方法，并改名成new方法：
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args);
// --snip--
}
// --snip--
impl Config {
fn new(args: &[String]) -> Config {
let query = args[1].clone();
let filename = args[2].clone();
Config { query, filename }
}
}
现在，我们再来处理一下异常，因为存在用户没有输入两个参数的可能性，所以我们判断当参数数量小于3时就抛出异常：
use std::env;
use std::fs;
use std::process;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {}", err);
process::exit(1);
});
// --snip--
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
let contents = fs::read_to_string(config.filename)
.expect("Something went wrong reading the file");
println!("With text:\n{}", contents);
}
struct Config {
query: String,
filename: String,
}
impl Config {
fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
再把文件处理逻辑提取出来：
fn main() {
// --snip--
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
run(config);
}
fn run(config: Config) {
let contents = fs::read_to_string(config.filename)
.expect("Something went wrong reading the file");
println!("With text:\n{}", contents);
}
// --snip--
同样的，也是要处理异常：
use std::error::Error;
// --snip--
fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
println!("With text:\n{}", contents);
Ok(())
}
main里面也要改下，当有error时退出：
fn main() {
// --snip--
println!("Searching for {}", config.query);
println!("In file {}", config.filename);
if let Err(e) = run(config) {
println!("Application error: {}", e);
process::exit(1);
}
}
好了，我们已经把可以提取出的内容都从main方法里面抽离了，现在我们把这些内容移到lib.rs中去：
use std::error::Error;
use std::fs;
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
// --snip--
}
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
// --snip--
}
在main.rs中需要引入这个crate：
use std::env;
use std::process;
use minigrep::Config;
fn main() {
// --snip--
if let Err(e) = minigrep::run(config) {
// --snip--
}
}
测试驱动开发
现在我们在lib中添加一个函数search，提供查询功能，先写一个空的：
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
vec![]
}
在lib.rs中写一个测试来测search：
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
}
这个测试必然会失败，因为search我们没有实现任何内容，返回的是一个空vector。现在修改search方法，让测试能通过：
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
search功能完成了，我们把它加到run函数中：
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
for line in search(&config.query, &contents) {
println!("{}", line);
}
Ok(())
}
现在我们就能使用minigrep实现筛选出的文件行了（我们去掉了无用的一些打印语句）：
$ cargo run body poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep body poem.txt`
I'm nobody! Who are you?
Are you nobody, too?
How dreary to be somebody!
再来写一个测试，我们希望增加一个对大小写敏感和不敏感的不同方法：
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn case_sensitive() {
let query = "duct";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";
assert_eq!(
vec!["Rust:", "Trust me."],
search_case_insensitive(query, contents)
);
}
}
那么我们需要写一个search_case_insensitive方法：
pub fn search_case_insensitive<'a>(
query: &str,
contents: &'a str,
) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
我们也给Config增加一个大小写是否敏感的参数：
pub struct Config {
pub query: String,
pub filename: String,
pub case_sensitive: bool,
}
修改run函数，增加大小写是否敏感的判断：
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
let results = if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
};
for line in results {
println!("{}", line);
}
Ok(())
}
修改new方法，我们不从命令行读取变量case_sensitive，而是从环境变量CASE_INSENSITIVE中读取：
use std::env;
// --snip--
impl Config {
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filename = args[2].clone();
let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
Ok(Config {
query,
filename,
case_sensitive,
})
}
}
这里用了is_err方法，当这个环境变量存在，会返回true，当不存在，则返回false。我们在命令行加上环境变量一起运行：
$ CASE_INSENSITIVE=1 cargo run to poem.txt
Finished dev [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep to poem.txt`
Are you nobody, too?
How dreary to be somebody!
To tell your name the livelong day
To an admiring bog!
控制错误输出
我们在main中，把错误输出改成用eprintln来进行标准错误输出：
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args).unwrap_or_else(|err| {
eprintln!("Problem parsing arguments: {}", err);
process::exit(1);
});
if let Err(e) = minigrep::run(config) {
eprintln!("Application error: {}", e);
process::exit(1);
}
}
完美了！
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 jimmyseraph@testops.vip
