目标

我们需要开发一个命令行工具，一个 mini 的 grep，grep（global search regular expression and print，全局搜索正则表达式并输出）命令在 Linux 中用于查找文件里符合条件的字符串。

我们要做的就是接收文件名和字符串作为参数，然后读取文件内容来搜索包含指定字符串的行，并打印输出，输入命令如下：

cargo run xxx xxx.txt

实现的关键步骤

项目创建

# 项目名称 minigrep
cargo new minigrep

cd minigrep

读取命令行参数

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect(); // 用于接收命令行中输入的参数
    
    let query = &args[1];
    let filename = &args[2];

    println!("{:?}", args);
    println!("Search for {}", query);
    println!("In file {}", filename);
}

运行：

cargo run xxx xxx.txt

输出：

["target/debug/minigrep", "xxx", "xxx.txt"]
Search for xxx
In file xxx.txt

读取文件

use std::env;
use std::fs; // 引入读取文件的标准库

fn main() {
    let args: Vec<String> = env::args().collect();
    
    let query = &args[1];
    let filename = &args[2];

    let contents = fs::read_to_string(filename) // 以字符串形式读取文件
    .expect("Something went wrong reading the file"); // 处理错误

    println!("With text:\n{}", contents);
}

在 minigrep 根目录下创建一个 poem.txt，随便写入一些文本信息。

运行

cargo run xxx poem.txt

将输出 poem.txt 里面的内容。

重构

现在 main.rs 负责的事情太多，又要负责解析参数，又要负责文件读取，而且错误处理也不太清晰。现在程序比较简单，但是后期如果项目越来越复杂，那么程序将很难或者无法维护，所以我们需要将职责进行拆分。

二进制程序关注点分离的指导性原则：

将程序拆分为 main.rs 和 lib.rs，将业务逻辑放入 lib.rs
当命令行解析逻辑较少时，将它放在 main.rs 也行
当命令行解析逻辑变复杂时，需要将它从 main.rs 提取到 lib.rs

命令行参数读取部分重构

创建 lib.rs，使用 struct 来处理参数，让代码更好理解。

// lib.rs
pub struct Config {
    pub query: String,
    pub filename: String,
}

impl Config {
    pub fn new(args: &Vec<String>) -> Config {
        let query = args[1].clone();
        let filename = args[2].clone();

        Config { query, filename }
    }
}

main.rs 的调用也需要修改。

// main.rs
use std::env;
use std::fs;
use minigrep::Config;

fn main() {
    let args: Vec<String> = env::args().collect();
    
    let config = Config::new(&args);

    let contents = fs::read_to_string(config.filename)
    .expect("Something went wrong reading the file");

    println!("With text:\n{}", contents);
}

错误处理部分的重构

在出现错误的时候现在命令行中的打印信息还是比较复杂和冗余的，有很多用户不关注的信息也都打印了出来，比如：thread 'main' panicked at 'Something went wrong reading the file: Os { code: 2, kind: NotFound, message: "系统找不到指定的文件。" }', src\main.rs:10:6 ...。

我们可以用 Result 枚举来进行错误处理，修改一下 new 函数的处理。

// lib.rs
impl Config {
    pub fn new(args: &Vec<String>) -> Result<Config, &str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }
        let query = args[1].clone();
        let filename = args[2].clone();

        Ok(Config { query, filename })
    }
}

修改 main.rs 的 Config 返回的处理。

// main.rs
use std::env;
use std::fs;
use std::process;
use minigrep::Config;

fn main() {
    let args: Vec<String> = env::args().collect();
    
    // unwrap_or_else 如果成功则返回数据，出错则会调用一个闭包（可以理解为一个匿名函数）
    let config = Config::new(&args).unwrap_or_else(|err| {
        println!("Problem parsing arguments: {}", err);
        process::exit(0);
    });

    let contents = fs::read_to_string(config.filename)
    .expect("Something went wrong reading the file");

    println!("With text:\n{}", contents);
}

提取 Run 函数进一步简化 main.rs 的逻辑

run 函数就是处理文件读取的这一段逻辑，我们将其提取出来。

// lib.rs
// 原来用的 expect 来进行错误处理，会导致 panic，所以这里也需要修改为 Result
pub fn run(config: Config) -> Result<(), Box<dyn Error>> { // Box<dyn Error> 暂时不用管
    let contents = fs::read_to_string(config.filename)?; // ? 传播错误，将错误返回给函数的调用者

    println!("With text:\n{}", contents);
    Ok(())
}

// main.rs
use std::env;
use std::process;
use minigrep::Config;

fn main() {
    let args: Vec<String> = env::args().collect();
    
    // unwrap_or_else 如果成功则返回数据，出错则会调用一个闭包（可以理解为一个匿名函数）
    let config = Config::new(&args).unwrap_or_else(|err| {
        println!("Problem parsing arguments: {}", err);
        process::exit(0);
    });

    if let Err(e) = minigrep::run(config) {
        println!("Application error: {}", e);
        process::exit(0);
    }
}

使用 TDD 编写库功能

TDD（Test-Driven Development），测试驱动开发，我们将用这种方式开发搜索关键字的功能。

TDD 的一般步骤如下：

编写一个会失败的测试，运行该测试，确保它是按照预期的原因失败
编写或修改刚好足够的代码，让新测试通过
重构刚刚添加或修改的代码，确保测试会始终通过
返回步骤1，继续

添加测试用例

// lib.rs
#[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));
    }
}

添加搜索函数

// lib.rs
pub fn search<'a>(query: &'a 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
}

修改 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(())
}

使用环境变量

使用环境变量来实现搜索的关键字区分大小写的功能。

也是用 TDD 开发，所以先修改一下测试用例：

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn case_sensitive() {
        let query = "duct";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.
Duck 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: &'a str, contents: &'a str) -> Vec<&'a str> {
    let mut results = Vec::new();
    let query = query.to_lowercase();
    for line in contents.lines() {
        if line.to_lowercase().contains(&query) {
            results.push(line);
        }
    }

    results
}

执行 cargo test，保证用例可以通过。

然后对 Config 进行修改：

use std::env; // 添加

pub struct Config {
    pub query: String,
    pub filename: String,
    pub case_sensitive: bool,
}

impl Config {
    pub fn new(args: &Vec<String>) -> Result<Config, &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 })
  }
}

再修改 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(())
}

执行 CASE_INSENSITIVE=1 cargo run rUst poem.txt 来启用环境变量（window 系统需要在最前面加 set）。

将错误信息输出到标准错误

标准输出：stdout -> println!

标准错误：stderr -> eprintln!

执行的时候加上 > output.txt，将标准输出输出到 output.txt 中，如果不进行任何代码修改，那么 output.txt 中既有正常输出信息又有错误信息，如果修改一下打印错误信息代码（println! -> eprintln!），那么错误信息就不会输出到 output.txt 中。

// main.rs
fn main() {
    let args: Vec<String> = env::args().collect();
    
    // unwrap_or_else 如果成功则返回数据，出错则会调用一个闭包（可以理解为一个匿名函数）
    let config = Config::new(&args).unwrap_or_else(|err| {
        eprintln!("Problem parsing arguments: {}", err);
        process::exit(0);
    });

    if let Err(e) = minigrep::run(config) {
        eprintln!("Application error: {}", e);
        process::exit(0);
    }
}

使用迭代器优化代码

// main.rs
fn main() {  
    let config = Config::new(env::args()).unwrap_or_else(|err| {
        eprintln!("Problem parsing arguments: {}", err);
        process::exit(0);
    });

    if let Err(e) = minigrep::run(config) {
        eprintln!("Application error: {}", e);
        process::exit(0);
    }
}

// lib.rs
impl Config {
    pub fn new(mut args: std::env::Args) -> Result<Config, &str> {
        if args.len() < 3 {
            return Err("not enough arguments");
        }

        args.next();
        let query = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a query string"),
        };
        let filename = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a query string"),
        };
        let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
        Ok(Config { query, filename, case_sensitive })
  }
}

pub fn search<'a>(query: &'a str, contents: &'a str) -> Vec<&'a str> {
    contents.lines()
        .filter(|line| line.contains(query))
        .collect()
}

pub fn search_case_insensitive<'a>(query: &'a str, contents: &'a str) -> Vec<&'a str> {
    let query = query.to_lowercase();
    contents.lines()
        .filter(|line| line.to_lowercase().contains(&query))
        .collect()
}

Rust 学习笔记 - 实战 mini grep

目标