[易学易懂系列|rustlang语言|零基础|快速入门|(24)|实战2:命令行工具minigrep(1)]
项目实战
实战2:命令行工具minigrep
有了昨天的基础,我们今天来开始另一个稍微有点复杂的项目。
简单来说,就是开发一个我们自己的grep (globally search a regular expression and print)
首先用命令生成一个工程:
cargo new minigrep
然后在工程目录minigrep下新建一个文件: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!
在工程目录下的src/main.rs文件中,填入以下代码:
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();//从命令行环境得到用户输入的参数
let query = &args[1];//参数1
let filename = &args[2];//参数2
println!("Searching for {}", query);//打印参数1
println!("In file {}", filename);//打印参数1
let contents = fs::read_to_string(filename).expect("Something went wrong reading the file");//以参数2为路径,读取文件内容
println!("With text:
{}", contents);//打印内容
}
我们现在用命令:
cargo run the poem.txt
结果将打印如下 信息:
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `targetdebugminigrep.exe 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!
成功了!
我们成功地从文件poem.txt中读取了相关内容信息。
好现在我们来重构一下代码!
为什么要重构代码?
因为我们的很多逻辑都写在一个main函数上,这是一个不好的现象,如果功能越多,代码也越多,最后可以出现一个超长的main函数。可读性和可维护性都很差!
所以从一开始,我们就要考虑代码的可读性和可维护性,这是最佳实践!
好,我们开始重构吧!
根据单一职责设计原则,一个方法只负责一个职责。
那我们就应该把main方法里的负责处理参数读取和参数搜索的逻辑,把它们分别抽离开来,放在单独的方法中。
我们先把处理参数读取的逻辑抽出来,如下:
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let (query, filename) = parseConfig(&args);//抽离参数读取与解析的逻辑
let contents = fs::read_to_string(filename).expect("Something went wrong reading the file");
println!("With text:
{}", contents);
}
//参数读取与解析的逻辑
fn parseConfig(args: &[String]) -> (&str, &str) {
println!("args len is {}", args.len());
println!("args is {:?}", args);
let query = &args[1];
let filename = &args[2];
println!("Searching for {}", query);
println!("In file {}", filename);
(query, filename)
}
同样,我们用命令:
cargo run the poem.txt
运行后的结果为:
args len is 3
args is [".\target\debug\minigrep.exe", "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!
很好,我们的程序正常运行。
我们再来看看把元组用一个结构体来替换,把相关参数属性放在一起,更简洁直观。
开始吧:
use std::env;
use std::fs;
fn main() {
let args: Vec<String> = env::args().collect();
let config: Config = parseConfig(&args);
let contents =
fs::read_to_string(config.filename).expect("Something went wrong reading the file");
println!("With text:
{}", contents);
}
//结构体Config用来封装参数属性
struct Config {
query: String,
filename: String,
}
//参数读取与解析的逻辑
fn parseConfig(args: &[String]) -> Config {
println!("args len is {}", args.len());
println!("args is {:?}", args);
let query = args[1].clone();//这里直接用clone方法得到一个参数string的拷贝
let filename = args[2].clone();//这里直接用clone方法得到一个参数string的拷贝
println!("Searching for {}", query);
println!("In file {}", filename);
Config { query, filename }//返回结构体
}
同样,我们用命令:
cargo run the poem.txt
运行后的结果跟原来一样,重构成功!
有同学会问,这里为什么用clone呢?
不会有性能问题吗?
因为简单!
我们先保持简单,让程序能跑起来,以后再考虑性能的问题。(事实上,这里的性能只损失很少一部分。)
很好!
能否再优化重构一下:参数读取与解析代码?
可以的。
我们看如下 代码:
use std::env;
use std::fs;
//主函数,程序入口
fn main() {
let args: Vec<String> = env::args().collect();
let config: Config = Config::new(&args);//直接调用Config构造函数
let contents =
fs::read_to_string(config.filename).expect("Something went wrong reading the file");
println!("With text:
{}", contents);
}
//结构体Config用来封装参数属性
struct Config {
query: String,
filename: String,
}
//为结构体实现一个构造器,其主要功能也是读取和解析参数
impl Config {
fn new(args: &[String]) -> Config {
let query = args[1].clone();
let filename = args[2].clone();
Config { query, filename }
}
}
//参数读取与解析的逻辑,现在可以删除了!
fn parseConfig(args: &[String]) -> Config {
println!("args len is {}", args.len());
println!("args is {:?}", args);
let query = args[1].clone();//这里直接用clone方法得到一个参数string的拷贝
let filename = args[2].clone();//这里直接用clone方法得到一个参数string的拷贝
println!("Searching for {}", query);
println!("In file {}", filename);
Config { query, filename }//返回结构体
}
同样,我们用命令:
cargo run the poem.txt
运行后的结果跟原来一样,重构成功!
这时,我们的函数:parseConfig,可以退休了。
好吧,直接把它删除!
同样,我们用命令:
cargo run the poem.txt
运行后的结果跟原来一样,删除成功!
这里为什么,每执行一次小版本的重构,都要跑一次代码呢?
因为可以保证,每次重构都是很小一步,可以避免错误!如果重构失败,也容易回退代码。
好吧,我们继续重构。
我们现在考虑一下错误处理。
比如,我们现在直接用命令:cargo run 运行代码,会报错:
$ cargo run
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/minigrep`
thread 'main' panicked at 'index out of bounds: the len is 1
but the index is 1', src/main.rs:25:21
note: Run with `RUST_BACKTRACE=1` for a backtrace.
好,我们现在在代码上加上错误处理的逻辑,修改Config的构造函数:
//为结构体实现一个构造器,其主要功能也是读取和解析参数
impl Config {
fn new(args: &[String]) -> Config {
if args.len() < 3 {
panic!("参数个数不够!not enough arguments");//增加错误处理
}
let query = args[1].clone();
let filename = args[2].clone();
Config { query, filename }
}
}
直接用命令:cargo run 运行代码,会报错,但错误信息明确多了:
Finished dev [unoptimized + debuginfo] target(s) in 0.96s
Running `targetdebugminigrep.exe`
thread 'main' panicked at '参数个数不够!not enough arguments', srcmain.rs:23:13
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
能否更优雅地处理错误信息?
可以,我们可以用Result,代码如下:
use std::env;
use std::fs;
use std::process;
//主函数,程序入口
fn main() {
let args: Vec<String> = env::args().collect();
// let config: Config = Config::new(&args);
let config = Config::new(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {}", err);
process::exit(1);
});
let contents =
fs::read_to_string(config.filename).expect("Something went wrong reading the file");
println!("With text:
{}", contents);
}
//结构体Config用来封装参数属性
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 })
}
}
直接用命令:cargo run 运行代码,会报错,错误信息一样:
Finished dev [unoptimized + debuginfo] target(s) in 0.96s
Running `targetdebugminigrep.exe`
thread 'main' panicked at '参数个数不够!not enough arguments', srcmain.rs:23:13
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
错误处理代码,重构成功!
我们再来跑一下正确的流程。
我们用命令:
cargo run the poem.txt
运行后的结果跟原来一样,很好!
现在我们再来重构一下main函数的对参数的处理逻辑,代码如下:
use std::env;
use std::fs;
use std::process;
//主函数,程序入口
fn main() {
let args: Vec<String> = env::args().collect();
// let config: Config = Config::new(&args);
let config = Config::new(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {}", err);
process::exit(1);
});
// let contents =
// fs::read_to_string(config.filename).expect("Something went wrong reading the file");
// println!("With text:
{}", contents)
run(config);//重构从文件中读取内容的业务逻辑
}
//结构体Config用来封装参数属性
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 run(config: Config) {
let contents = fs::read_to_string(config.filename)
.expect("从文件中读取内容时出错!Something went wrong reading the file");
println!("With text:
{}", contents);
}
我们用命令:
cargo run the poem.txt
运行后的结果跟原来一样,重构成功!
我们再来让run方法有返回值,这样,主程序更好处理,看代码:
use std::env;
use std::error::Error;
use std::fs;
use std::process;
//主函数,程序入口
fn main() {
let args: Vec<String> = env::args().collect();
// let config: Config = Config::new(&args);
let config = Config::new(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {}", err);
process::exit(1);
});
if let Err(e) = run(config) {
//根据处理结果返回值 来处理,如果有错误,则打印信息,并直接退出当前程序
println!("Application error: {}", e);
process::exit(1);
}
}
//结构体Config用来封装参数属性
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 run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
println!("With text:
{}", contents);
Ok(())
}
我们用命令:
cargo run the poem.txt
运行后的结果跟原来一样,重构成功!
非常好!
现在我们再来重构,把main函数,所有业务逻辑迁移到lib.rs文件。
我们来看看怎么重构。
首先,我们先在工程目录下的目录src下创建另一个文件lib.rs,并把main函数相关代码写入进去:
use std::error::Error;
use std::fs;
//结构体Config用来封装参数属性
pub struct Config {
query: String,
filename: String,
}
//为结构体实现一个构造器,其主要功能也是读取和解析参数
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();
Ok(Config { query, filename })
}
}
//重构从文件中读取内容的业务逻辑
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.filename)?;
println!("With text:
{}", contents);
Ok(())
}
这时src/main.rs的代码更新为如下:
use minigrep::run;
use minigrep::Config;
use std::env;
use std::process;
//主函数,程序入口
fn main() {
let args: Vec<String> = env::args().collect();
// let config: Config = Config::new(&args);
let config = Config::new(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {}", err);
process::exit(1);
});
if let Err(e) = run(config) {
//根据处理结果返回值 来处理,如果有错误,则打印信息,并直接退出当前程序
println!("Application error: {}", e);
process::exit(1);
}
}
我们用命令:
cargo run the poem.txt
运行后的结果跟原来一样,重构成功!
完美!
我们已经有一个能运行的基本程序框架。
以上,希望对你有用。
如果遇到什么问题,欢迎加入:rust新手群,在这里我可以提供一些简单的帮助,加微信:360369487,注明:博客园+rust
参考文章:
https://doc.rust-lang.org/stable/book/ch12-00-an-io-project.html