按照文档来造个 grep 的 CLI 工具，适当脱离文档加一些自己想要的功能。

先创建个项目叫 minigrep

  1. $ cargo new minigre

再在 src目录下加个 lib.rs用来写核心逻辑，然后在 main.rs中只是使用 lib 中提供的函数进行逻辑组合。

Config

在 lib 中写个 Config 结构用来封装 grep 的关键词和文件名，并且暴露个 run 的执行方法，入参就是 Config

  1. // src/lib.rs
  3. pub struct Config {
  4.   pub query: String,
  5.   pub filename: String,
  6. }
  8. impl Config {
  9.   pub fn new(args: &[String]) -> Result<Config, &str> {
  10.     if args.len() < 3 {
  11.       Err("not engough arguments")
  12.     } else {
  13.       Ok(Config {
  14.         query: args[1].clone(),
  15.         filename: args[2].clone(),
  16.       })
  17.     }
  18.   }
  19. }
  21. pub fn run(config: Config) -> Result<String, Box<dyn Error>> {
  22.   // ...
  23. }

获取 args

在 main 中引入 lib 中的 Config 以及 run 方法，通过 env 这个库获取 args 

  1. // src/main.rs
  3. use std::{env, process};
  4. use minigrep::{Config, run};
  6. fn main() {
  7.     let args: Vec<String> = env::args().collect();
  8.     let config = Config::new(&args).unwrap_or_else(|err| {
  9.         println!("parse arguments failed with reason: {}", err);
  10.         process::exit(1);
  11.     });
  13.     let result = run(config);
  14.     if let Err(e) = result {
  15.         println!("execute failed with {:?}", e)
  16.     } else if let Ok(str) = result {
  17.         println!("{}", str);
  18.     }
  19. }

可以通过 process:exit(1) 来退出进程，类似于 node 中的 process.exit 。

文件读取

前面的文档就有学过文件读取，可以直接用 fs 这个库的 api 操作，通过 or_else 可以对错误信息做预处理。

  1. // src/lib.rs
  3. pub fn run(config: Config) -> Result<String, Box<dyn Error>> {
  4.     let contents = fs::read_to_string(&config.filename)
  5.         .or_else(|err| {
  6.           if err.kind() == ErrorKind::NotFound {
  7.             Err(format!("failed to read file: {}", config.filename))
  8.           } else {
  9.             Err(format!("{:?}", err))
  10.           }
  11.         })?;
  13.     // do other things
  14. }

字符操作

前面从文件读出内容后，通过 search 方法查询包含关键词的那一行，封装一个 SearchResult 的结构，用于存储检索到的内容，以及行数。

  1. pub struct SearchResult<'a> {
  2.   pub line: usize,
  3.   pub content: &'a str,
  4. }
  6. pub fn search<'a>(query: &String, contents: &'a String) -> Vec<SearchResult<'a>> {
  7.   let mut list = Vec::new();
  9.   // enumerate 可以返回一个 tuple ，第一个是 index ，第二个是 value
  10.   for (i, str) in contents.lines().enumerate() {
  11.     // 如果包含 query 信息，就收集内容
  12.     if str.contains(query) {
  13.       list.push(SearchResult {
  14.         line: i + 1,
  15.         content: str,
  16.       });
  17.     }
  18.   }
  19.   list
  20. }

但是只是查出来还不够，还想优化一下，想实现类似于下面这种效果，也就是能标记出匹配的内容，并且能不区分大小写。

  1.   Search 123 in search.txt
  3.        1. |   123
  4.           |   ^^^
  5.        2. |   123
  6.           |   ^^^
  7.        3. |   aaaaaa  123 bb
  8.           |           ^^^

优化匹配

原来是用字符串的 contains 方法，如果需要实现上面的效果，可以改成 match_indices 方法，这个方法能返回匹配的内容和匹配了第几个字符。

然后在 SearchResult里再新增个 underline的内容，用来存储下划线信息。

  1. // src/lib.rs
  2. pub struct SearchResult<'a> {
  3.   pub line: usize,
  4.   pub content: &'a str,
  5.   pub underline: String,
  6. }
  8. pub fn search<'a>(query: &String, contents: &'a String) -> Vec<SearchResult<'a>> {
  9.   let mut list = Vec::new();
  11.   // 统一小写
  12.   let lower_query = query.to_lowercase();
  14.   for (i, str) in contents.lines().enumerate() {
  15.     // 先转成小写再去匹配，to_lowercase 会将字符拷贝一份
  16.     let lower_str = str.to_lowercase();
  18.     // 进行匹配 
  19.     let matches: Vec<(usize, &str)> = lower_str.match_indices(&lower_query).collect();
  21.     // 如果 match 数量大于 0 ，就说明匹配中了
  22.     if matches.len() > 0 {
  23.       list.push(SearchResult {
  24.         line: i + 1,
  25.         content: str,
  26.         underline: create_underline(&matches)
  27.       });
  28.     }
  29.   }
  30.   list
  31. }
  33. // 根据 match 的结果，返回 underline 内容
  34. pub fn create_underline(matches: &Vec<(usize, &str)>) -> String {
  35.   let mut underline = String::new();
  36.   let mut index = 0;
  37.   for (match_index, match_str) in matches {
  38.     let space_len = match_index - index;
  40.     // 根据匹配结果，生成 ^^^ 的内容。
  41.     underline.push_str(&format!("{}{}", " ".repeat(space_len), "^".repeat(match_str.len())));
  43.     index = *match_index + match_str.len();
  44.   }
  45.   underline
  46. }

逻辑组合

再在 run 函数中调用 search 方法，拿到 SearchResult列表，再组合成要打印的信息返回。

  1. // src/lib.rs
  3. pub fn run(config: Config) -> Result<String, Box<dyn Error>> {
  4.   // ...snip...
  6.   let result = search(&config.query, &contents);
  8.   // 格式化输出结果
  9.   let mut str_result = String::new();
  10.   str_result.push_str(&format!("\n  Search {} in {}\n", config.query, config.filename));
  11.   for r in result {
  12.     let prefix = format!("{}{}", " ".repeat(6 - r.line.to_string().len()), r.line);
  13.     str_result.push_str(&format!("\n  {}. |   {}\n", prefix, r.content));
  14.     str_result.push_str(&format!("  {}  |   {}", " ".repeat(prefix.len()), r.underline));
  15.   }
  16.   str_result.push_str("\n");
  18.   Ok(str_result)
  19. }

因为在 main.rs 中是直接打印 run函数返回的字符信息，然后测试一下

aaa 为关键词，search.txt 为检索的文本。

  1. $ cargo run aaa search.txt

效果如下
image.png

单元测试

写代码必须得测试驱动，所以单测不能忘记，简单写两个先 …

  1. // src/lib.rs
  3. // ...snip...
  5. #[cfg(test)]
  6. mod tests {
  7.   use super::*;
  9.   #[test]
  10.   fn config_should_works() {
  11.     let args = [ String::from("a") ];
  12.     let conf = Config::new(&args);
  13.     match conf {
  14.         Err(e) => {
  15.           assert_eq!(e, "not engough arguments");
  16.         },
  17.         _ => panic!("should throw error")
  18.     }
  19.   }
  21.   #[test]
  22.   fn should_search_without_error() {
  23.     let mut query = String::from("duct");
  24.     let contents = "
  25. Rust:
  26. safe, fast, productive.
  27. Pick three.
  28.       ".to_string();
  30.     let result = search(&query, &contents);
  31.     assert_eq!(result.len(), 1);
  32.     assert_eq!(result[0].line, 3);
  33.     assert_eq!(result[0].content, "safe, fast, productive.");
  34.     assert_eq!(result[0].underline, "               ^^^^");
  36.     query.clear();
  37.     query.push_str("u");
  38.     let result2 = search(&query, &contents);
  39.     assert_eq!(result2.len(), 2);
  40.     assert_eq!(result2[0].line, 2);
  41.     assert_eq!(result2[0].content, "Rust:");
  42.     assert_eq!(result2[1].line, 3);
  43.     assert_eq!(result2[1].content, "safe, fast, productive.");
  44.   }
  45. }