23_rust_练习
练习编码
实现一个简单的grep工具。
建立项目：
> cargo new minigrep
Created binary (application) `minigrep` package
接收命令行参数
use std::env;
fn main() {
// args返回一迭代器，collect将迭代器转换为Vector，需指明类型
// args函数无法处理非法Unicode字符，如果输入了非法unicode字符则panic
let args : Vec<String> = env::args().collect();
// 如果要接收非法Unicode字符，需要使用env::args_os(), 这个返回的是OsString
println!("{:?}", args);
let query = &args[1];
let filename = &args[2];
println!("{}, {}", query, filename);
}
读取文件
use std::env;
use std::fs; // 处理与文件相关的事务
fn main() {
// args返回一迭代器，collect将迭代器转换为Vector，需指明类型
// args函数无法处理非法Unicode字符，如果输入了非法unicode字符则panic
let args : Vec<string> = env::args().collect();
// 如果要接收非法Unicode字符，需要使用env::args_os(), 这个返回的是OsString
println!("{:?}", args);
let query = &args[1];
let filename = &args[2];
println!("{}, {}", query, filename);
// read_to_string返回的是Result结果，如果是OK，则返回读取内容，如果失败则调用expect方法
let contents = fs::read_to_string(filename).expect("read file faild");
println!("read file txt:{}", contents);
}
按功能重构代码
二进制程序关注点分离指导原则：
- 将程序拆分为main.rs和lib.rs，将业务逻辑放入lib.rs
- 当命令行解析逻辑较少时，将它放在main.rs也可
- 当命令行解析逐渐复杂，需提取到lib.rs
use std::env;
use std::fs; // 处理与文件相关的事务
fn main() {
// args返回一迭代器，collect将迭代器转换为Vector，需指明类型
// args函数无法处理非法Unicode字符，如果输入了非法unicode字符则panic
let args : Vec<String> = env::args().collect();
// 如果要接收非法Unicode字符，需要使用env::args_os(), 这个返回的是OsString
println!("{:?}", args);
let (query, filename) = parse_args(&args);
println!("{}, {}", query, filename);
// read_to_string返回的是Result结果，如果是OK，则返回读取内容，如果失败则调用expect方法
let contents = fs::read_to_string(filename).expect("read file faild");
println!("read file txt:{}", contents);
}
/**
* @args: Vec切片，String类型元素
* Return: 元组类型，数据是两个字符串切片，分别是查询关键字和文件名
*/
fn parse_args(args: &[String]) -> (&str, &str) {
let query = &args[1];
let filename = &args[2];
(query, filename)
}
返回值的元组的内容，实际是相关联的，可建立一个结构体。
use std::env;
use std::fs; // 处理与文件相关的事务
fn main() {
// args返回一迭代器，collect将迭代器转换为Vector，需指明类型
// args函数无法处理非法Unicode字符，如果输入了非法unicode字符则panic
let args : Vec<String> = env::args().collect();
// 如果要接收非法Unicode字符，需要使用env::args_os(), 这个返回的是OsString
let cfg = parse_config(&args);
println!("{}, {}", cfg.query, cfg.filename);
// read_to_string返回的是Result结果，如果是OK，则返回读取内容，如果失败则调用expect方法
let contents = fs::read_to_string(cfg.filename).expect("read file faild");
println!("read file txt:{}", contents);
}
struct Config {
query: String,
filename: String,
}
/**
* @args: Vec切片，String类型元素
* Return: Config实例，携带待查关键字和文件名信息
*/
fn parse_config(args: &[String]) -> Config {
let query = args[1].clone();
let filename = args[2].clone();
Config { query, filename }
}
而parse_config是构造一个Config实例，所以可实现成new函数(main.rs)：
use std::env;
use std::fs; // 处理与文件相关的事务
fn main() {
// args返回一迭代器，collect将迭代器转换为Vector，需指明类型
// args函数无法处理非法Unicode字符，如果输入了非法unicode字符则panic
let args : Vec<String> = env::args().collect();
// 如果要接收非法Unicode字符，需要使用env::args_os(), 这个返回的是OsString
println!("{:?}", args);
let cfg = Config::new(&args);
println!("{}, {}", cfg.query, cfg.filename);
// read_to_string返回的是Result结果，如果是OK，则返回读取内容，如果失败则调用expect方法
let contents = fs::read_to_string(cfg.filename).expect("read file faild");
println!("read file txt:{}", contents);
}
struct Config {
query: String,
filename: String,
}
impl Config {
/**
* @args: Vec切片，String类型元素
* Return: Config实例，携带待查关键字和文件名信息
*/
fn new(args: &[String]) -> Config {
let query = args[1].clone();
let filename = args[2].clone();
Config { query, filename }
}
}
当前这种情况，运行缺少参数时会直接超索引而崩溃了，所以需要进行错误处理重构，当输入参数不正确时，告知用户原因：
use std::env;
use std::fs; // 处理与文件相关的事务
use std::process;
fn main() {
// args返回一迭代器，collect将迭代器转换为Vector，需指明类型
// args函数无法处理非法Unicode字符，如果输入了非法unicode字符则panic
let args : Vec<String> = env::args().collect();
// 如果要接收非法Unicode字符，需要使用env::args_os(), 这个返回的是OsString
println!("{:?}", args);
// 增加错误处理逻辑，使用unwrap_or_else函数，如果Ok则将结果赋值给cfg，如果失败则会调用一个传入的闭包
let cfg = Config::new(&args).unwrap_or_else(|err| { // 闭包语法，匿名语法
println!("args parse err: {}", err);
process::exit(1); // 程序退出，状态码1
});
println!("{}, {}", cfg.query, cfg.filename);
// read_to_string返回的是Result结果，如果是OK，则返回读取内容，如果失败则调用expect方法
let contents = fs::read_to_string(cfg.filename).expect("read file faild");
println!("read file txt:{}", contents);
}
struct Config {
query: String,
filename: String,
}
impl Config {
/**
* @args: Vec切片，String类型元素
* Return: Result，Ok时Config实例，携带待查关键字和文件名信息，
* Err时，返回一字符串字面指（静态生命周期，字符串切片）
*/
fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
// panic!("need 3 args"); // 一般程序本身错误时才用panic
// 处理用户使用错误一般用Result，所以需设置返回值为Result类型
return Err("need 3 args");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
/*运行结果：
cargo run
Compiling minigrep v0.1.0 (D:\courses\rust\01_hello_cargo\minigrep)
Finished dev [unoptimized + debuginfo] target(s) in 0.57s
Running `target\debug\minigrep.exe`
["target\\debug\\minigrep.exe"]
args parse err: need 3 args
error: process didn't exit successfully: `target\debug\minigrep.exe` (exit code: 1)
*/
一般main函数会把除了配置解析和错误处理之外的所有逻辑都移到run函数里，让main函数的逻辑精简到能够通过阅读代码检查正确性，其他逻辑则通过测试验证正确性。
创建src/lib.rs文件：
use std::fs; // 处理与文件相关的事务
use std::error::Error;
pub fn run(cfg: Config) -> Result<(), Box<dyn Error>> {
println!("{}, {}", cfg.query, cfg.filename);
// 原理的expect方法发生错误时会panic，使用?运算符，则发生错误时不会panic，而是会将错误返回给调用者处理
let contents = fs::read_to_string(cfg.filename)?;
println!("read file txt:{}", contents);
Ok(())
}
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
/**
* @args: Vec切片，String类型元素
* Return: Result，Ok时Config实例，携带待查关键字和文件名信息，
* Err时，返回一字符串字面指（静态生命周期，字符串切片）
*/
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
// panic!("need 3 args"); // 一般程序本身错误时才用panic
// 处理用户使用错误一般用Result，所以需设置返回值为Result类型
return Err("need 3 args");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
main.rs内容：
use std::env;
use std::process;
use minigrep::Config;
fn main() {
// args返回一迭代器，collect将迭代器转换为Vector，需指明类型
// args函数无法处理非法Unicode字符，如果输入了非法unicode字符则panic
let args : Vec<String> = env::args().collect();
// 如果要接收非法Unicode字符，需要使用env::args_os(), 这个返回的是OsString
// 增加错误处理逻辑，使用unwrap_or_else函数，如果Ok则将结果赋值给cfg，如果失败则会调用一个传入的闭包
let cfg = Config::new(&args).unwrap_or_else(|err| { // 闭包语法，匿名语法
println!("args parse err: {}", err);
process::exit(1); // 程序退出，状态码1
});
if let Err(e) = minigrep::run(cfg) {
println!("run err: {}", e);
process::exit(1);
}
}
模块化完成，接下来可写测试代码。
测试驱动开发（TDD）
TDD（Test-Driven Development），设计好场景，通过测试用例覆盖，确保代码完整且足够应付异常情况，当进一步升级，则补充新增场景，保障代码持续改进。
lib.rs内容修改成如下：
use std::fs; // 处理与文件相关的事务
use std::error::Error;
pub fn run(cfg: Config) -> Result<(), Box<dyn Error>> {
println!("{}, {}", cfg.query, cfg.filename);
// 原理的expect方法发生错误时会panic，使用?运算符，则发生错误时不会panic，而是会将错误返回给调用者处理
let contents = fs::read_to_string(cfg.filename)?;
for line in search_txt(&cfg.query, &contents) {
println!("{}", line);
}
Ok(())
}
pub struct Config {
pub query: String,
pub filename: String,
}
impl Config {
/**
* @args: Vec切片，String类型元素
* Return: Result，Ok时Config实例，携带待查关键字和文件名信息，
* Err时，返回一字符串字面指（静态生命周期，字符串切片）
*/
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
// panic!("need 3 args"); // 一般程序本身错误时才用panic
// 处理用户使用错误一般用Result，所以需设置返回值为Result类型
return Err("need 3 args");
}
let query = args[1].clone();
let filename = args[2].clone();
Ok(Config { query, filename })
}
}
// 因为返回的字符串切片是contents里的内容，所以生命周期要一致
pub fn search_txt<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut ret = Vec::new();
for line in contents.lines() {
if line.contains(query) {
ret.push(line);
}
}
ret
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_search() {
let query = "test";
let src_txt = "src multi txt:\nrust test search.\ntest txt.";
assert_eq!(vec!["rust test search.", "test txt."], search_txt(query, src_txt));
}
}
添加区分大小写
lib.rs内容
use std::fs; // 处理与文件相关的事务
use std::error::Error;
use std::env;
pub fn run(cfg: Config) -> Result<(), Box<dyn Error>> {
println!("{}, {}", cfg.query, cfg.filename);
// 原理的expect方法发生错误时会panic，使用?运算符，则发生错误时不会panic，而是会将错误返回给调用者处理
let contents = fs::read_to_string(cfg.filename)?;
let ret = if cfg.case_sensitive {
search_txt(&cfg.query, &contents)
} else {
search_case_insensitive(&cfg.query, &contents)
};
for line in ret {
println!("{}", line);
}
Ok(())
}
pub struct Config {
pub query: String,
pub filename: String,
pub case_sensitive: bool, // 添加一个大小写敏感的字符串
}
impl Config {
/**
* @args: Vec切片，String类型元素
* Return: Result，Ok时Config实例，携带待查关键字和文件名信息，
* Err时，返回一字符串字面指（静态生命周期，字符串切片）
*/
pub fn new(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
// panic!("need 3 args"); // 一般程序本身错误时才用panic
// 处理用户使用错误一般用Result，所以需设置返回值为Result类型
return Err("need 3 args");
}
let query = args[1].clone();
let filename = args[2].clone();
// 获取环境变量，只要CASE_INSENS环境变量出现，就认为不区分大小写，
// var函数返回一个Result，只要设置了就返回Ok里的值，未设置环境变量则返回Err，
// 这里用is_err检测是否发生了错误即可。这里只关心有没出现，不关心具体值，所以不需要处理err。
let case_sensitive = env::var("CASE_INSENS").is_err();
Ok(Config { query, filename, case_sensitive })
}
}
// 因为返回的字符串切片是contents里的内容，所以生命周期要一致
pub fn search_txt<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut ret = Vec::new();
for line in contents.lines() {
if line.contains(query) {
ret.push(line);
}
}
ret
}
pub fn search_case_insensitive<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut ret = Vec::new();
let query = query.to_lowercase(); // 会创建一个新的字符串，拥有所有权
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
ret.push(line);
}
}
ret
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_search() {
let query = "test";
let src_txt = "src multi txt:\nrust test search.\ntest txt.";
assert_eq!(vec!["rust test search.", "test txt."], search_txt(query, src_txt));
}
#[test]
fn test_case_sensitive() {
let query = "test";
let src_txt = "src multi txt:\nrust test search.\nTest txt.";
assert_eq!(vec!["rust test search.",], search_txt(query, src_txt));
}
#[test]
fn test_case_insensitive() {
let query = "test";
let src_txt = "src multi txt:\nrust TEST search.\nTest txt.";
assert_eq!(vec!["rust TEST search.", "Test txt."], search_case_insensitive(query, src_txt));
}
}
使用cargo test与CASE_INSENS=1 && cargo run test test.txt运行正确
将错误信息输出到标准错误
标准输出：stdout，使用println!。
标准错误：stderr，使用eprintln!。
main.rs的内容：
use std::env;
use std::process;
use minigrep::Config;
fn main() {
// args返回一迭代器，collect将迭代器转换为Vector，需指明类型
// args函数无法处理非法Unicode字符，如果输入了非法unicode字符则panic
let args : Vec<String> = env::args().collect();
// 如果要接收非法Unicode字符，需要使用env::args_os(), 这个返回的是OsString
// 增加错误处理逻辑，使用unwrap_or_else函数，如果Ok则将结果赋值给cfg，如果失败则会调用一个传入的闭包
let cfg = Config::new(&args).unwrap_or_else(|err| { // 闭包语法，匿名语法
eprintln!("args parse err: {}", err);
process::exit(1); // 程序退出，状态码1
});
if let Err(e) = minigrep::run(cfg) {
eprintln!("run err: {}", e);
process::exit(1);
}
}
使用cargo run test test.txt > result.txt和cargo run > result.txt测试，可见发生错误时，错误信息依然能打印到屏幕。
