Rust for cpp devs - minigrep 项目

官方文档用 minigrep 项目来讲解如何组织一个 Rust 项目。

保持 main 函数简洁

这样做的好处是：

• 可读性更强
• 由于无法直接测试 main 函数，分隔业务逻辑更利于单元测试

将 tuple 替换为 struct

struct 为每个字段赋予一个有意义的名字，可以提高可读性。

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

构造函数

将 parse_config 函数替换为构造函数 Config::new 可以让其更符合 Rust 习惯。就像标准库的 String::new。

impl Config {
    fn new(args: &[String]) -> Result<Config, &str> {
        if arg.len() < 3 {
            return Err("not enough arguments, usage: {} <pattern> <file>", args[0]);
        }

        return Ok(
            Config{
                query: args[1].clone(),
                filename: args[2].clone(),
        });
    }
}

构造函数返回值是 Result，它是一个 Enum 类型，用于错误处理。若构造成功，返回 Ok 的类型，在这里是 Config，否则返回 Err 类型，这里是 &str。

错误处理

由于构造函数不一定能成功，我们需要进行错误处理。在返回 Err 的情况打印错误信息，并调用 exit(1)。

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--

这里用到了 unwrap_or_else 方法，如果构造函数返回的不是 Ok 而是 Err，就会调用后面的 closure，并退出程序。

将代码分离到 Library Crate

main.rs 的代码控制程序的运行，lib.rs 的代码控制具体的业务逻辑。

将代码放到 lib.rs 可以将功能模块化，对测试更友好。

分离后，lib.rs 中的代码：

// lib.rs
use std::fs;
use std::error::Error;
use std::env;

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

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

pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
    let contents = fs::read_to_string(config.filename)?;

    let result = if config.case_sensitive {
        search(&config.query, &contents)
    } else {
        search_case_insensitive(&config.query, &contents)
    };

    for line in result {
        println!("{}", line);
    }

    return Ok(());
}

pub fn search<'a>(pattern: &str, contents: &'a str) -> Vec<&'a str> {
    let mut result = Vec::new();
    for line in contents.lines() {
        if line.contains(pattern) {
            result.push(line);
        }
    }
    return result;
}

pub fn search_case_insensitive<'a>(pattern: &str, contents: &'a str) -> Vec<&'a str> {
    let pattern = pattern.to_lowercase();

    let mut result = Vec::new();
    for line in contents.lines() {
        if line.to_lowercase().contains(pattern.as_str()) {
            result.push(line);
        }
    }

    return result;
}

注意，作为一个模块，凡是需要在外部调用的，我们都加了 pub 关键字。

main.rs 的内容为：

// main.rs

use std::env;
use std::process;

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

    let cfg = minigrep::Config::new(&args).unwrap_or_else(
        |err| {
            println!("Problem parsing arguments: {}", err);
            process::exit(1);
        }
    );

    println!("search {} from {}", cfg.query, cfg.filename);

    if let Err(e) = minigrep::run(cfg) {
        println!("Application error: {}", e);

        process::exit(1);
    }
}

注意，我们在调用 lib.rs 的方法时需要添加包的名字，即 minigrep。在 Cargo.toml 文件中可以找到这个名字。

使用 closure 和 iterator 优化

在上面的实现中，存在两个问题：

• 在 Config::new 函数中，使用了 clone，在该场景下可以用 iterator 优化，避免拷贝。

• 在 search 函数中，可以用 Iterator::filter，更为简洁。

使用 Iterator 避免 clone

首先，在 main 函数中，我们可以不急着将 env::args() 转为 Vec，而是将这个 Iterator 直接作为参数传递给 Config::new：

    let cfg = minigrep::Config::new(env::args()).unwrap_or_else(
        |err| {
            println!("Problem parsing arguments: {}", err);
            process::exit(1);
        }
    );

此外，我们需要针对下面的代码进行改进：

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

改进后版本：

impl Config {
    pub fn new(mut args: env::Args) -> Result<Config, &'static str> {
        args.next(); // skip the first arg

        let query = match args.next() {
            Some(arg) => arg,
            None => return Err("missing query string"),
        };

        let filename = match args.next() {
            Some(arg) => arg,
            None => return Err("missing file name"),
        };

        return Ok(
            Config{
                query: query,
                filename: filename,
                case_sensitive: env::var("CASE_INSENSITIVE").is_err(),
        });
    }
}

有几个点需要注意：

• 输入参数类型变更为 mut env::Args。mut 是因为这是一个 Iterator，在遍历中会被更改。

• 需要指定返回值生命周期 &'static str。改之前，由于输入参数是引用&[String]，所以输出的引用的生命周期直接继承，无需指定。

• 通过 next 而非 index 来获取参数。

经过这些改动，我们无需再 clone 字符串。

使用 filter 增强可读性

pub fn search<'a>(pattern: &str, contents: &'a str) -> Vec<&'a str> {
    let mut result = Vec::new();
    for line in contents.lines() {
        if line.contains(pattern) {
            result.push(line);
        }
    }
    return result;
}

使用 filter 后简洁了许多：

pub fn search<'a>(pattern: &str, contents: &'a str) -> Vec<&'a str> {
    let result = contents.lines().filter(|line| line.contains(pattern)).collect();

    return result;
}