2023-5-14，完成于新冠病隔离期间。是我学习rust起步，意在通过这个小的项目，学习一些基本的rust的思想，熟悉rust的基本语法知识。

(资料图片)

学习到的内容总结

• 关注分离点：把程序的启动放到main，主体逻辑移入库实现
• 聚合变量，将与某件事情有关的所有变量，聚合起来，同时也赋予其相应的方法
• 测试驱动的逻辑，先写一个绝对失败的例子，再写一个绝对成功的例子，编写你的代码逻辑，直到成功
• 使用环境变量，来增加程序的撸棒性
• 错误处理的两种逻辑：主动与被动
• 日志分离，普通日志与错误信息提示
• 迭代器遍历，更加简洁且完整，性能与安全性大幅度提升
• IO处理，要明白，一切用户输入都是不可信的输入
• 使用？返回特征对象，用Box来存储动态的特征对象指针
• 代码分离，对象抽象

Rust知名项目grep替代

https://github.com/BurntSushi/ripgrep

实现的功能

ps：查看cargo参数的方法，cargo --list

• input：指定文件和待查找的字符串
• output：返回查找结果

大体的形式

传入，--告诉后面的参数给程序使用而不是cargo

cargo run -- searchstring example-filename.txt

程序接受参数并且处理

//in main.rs//引入环境包，可以处理传入的参数use std::env;fn main() {    //将内容转换为数组集合    let args: Vec = env::args().collect();    //使用 dbg！宏，读取数组内容    dbg!(args);}

尝试一下

env::args` 读取到的参数中第一个就是程序的可执行路径名

$ cargo run   Compiling minigrep v0.1.0 (file:///projects/minigrep)    Finished dev [unoptimized + debuginfo] target(s) in 0.61s     Running `target/debug/minigrep`[src/main.rs:5] args = [    "target/debug/minigrep",]

$ cargo run   Compiling minigrep v0.1.0 (file:///projects/minigrep)    Finished dev [unoptimized + debuginfo] target(s) in 0.61s     Running `target/debug/minigrep`[src/main.rs:5] args = [    "target/debug/minigrep",]

不可信输入

这里，选择直接了当，让用户知道自己错了，而不是人为去处理这些不可信输入。

这里有一个思考的点：就是不可信输入的处理想法

所有的用户输入都不可信！不可信！不可信！重要的话说三遍，我们的命令行程序也是，用户会输入什么你根本就不知道，例如他输入了一个非 Unicode 字符，你能阻止吗？显然不能，但是这种输入会直接让我们的程序崩溃！原因是当传入的命令行参数包含非 Unicode 字符时， std::env::args 会直接崩溃，如果有这种特殊需求，建议大家使用 std::env::args_os，该方法产生的数组将包含 OsString 类型，而不是之前的 String 类型，前者对于非 Unicode 字符会有更好的处理。至于为啥我们不用，两个理由，你信哪个：1. 用户爱输入啥输入啥，反正崩溃了，他就知道自己错了 2. args_os 会引入额外的跨平台复杂性

项目创建

cargo new minigrep     Created binary (application) `minigrep` project$ cd minigrep

实现基本的功能

存储读取到的参数

给予清晰合理的变量名是一项基本功，咱总不能到处都是 args[1] 、args[2] 这样的糟糕代码吧。

//in main.rs//引入环境包，可以处理传入的参数use std::env;fn main() {    //将内容转换为数组集合    let args: Vec = env::args().collect();    //待搜查字符串    //存储文件路径    let query = &args[1];    let file_path = &args[2];    println!("Searching jfor {}",query);    println!("In file {}",file_path);    //使用 dbg！宏，读取数组内容    //dbg!(args);}

文件读取

在根目录创建内容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!传遍整个无聊的沼泽！

代码逻辑

use std::fs;    //省略    //读取文件内容，记得异常处理    let context = fs::read_to_string(file_path)        .expect("Should have been able to read the file!");    //捕获变量输出    print!("With text:\n {context}"); 

不足点总结

完美，虽然代码还有很多瑕疵，例如所有内容都在 main 函数，这个不符合软件工程，没有错误处理，功能不完善等。不过没关系，万事开头难，好歹我们成功迈开了第一步。但凡稍微没那么糟糕的程序，都应该具有代码模块化和错误处理，不然连玩具都谈不上。梳理我们的代码和目标后，可以整理出大致四个改进点:

• 单一且庞大的函数。对于 minigrep 程序而言， main 函数当前执行两个任务：解析命令行参数和读取文件。但随着代码的增加，main 函数承载的功能也将快速增加。从软件工程角度来看，一个函数具有的功能越多，越是难以阅读和维护。因此最好的办法是将大的函数拆分成更小的功能单元。
• 配置变量散乱在各处。还有一点要考虑的是，当前 main 函数中的变量都是独立存在的，这些变量很可能被整个程序所访问，在这个背景下，独立的变量越多，越是难以维护，因此我们还可以将这些用于配置的变量整合到一个结构体中。
• 细化错误提示。 目前的实现中，我们使用 expect 方法来输出文件读取失败时的错误信息，这个没问题，但是无论任何情况下，都只输出 Should have been able to read the file 这条错误提示信息，显然是有问题的，毕竟文件不存在、无权限等等都是可能的错误，一条大一统的消息无法给予用户更多的提示。
• 使用错误而不是异常。 假如用户不给任何命令行参数，那我们的程序显然会无情崩溃，原因很简单：index out of bounds，一个数组访问越界的 panic，但问题来了，用户能看懂吗？甚至于未来接收的维护者能看懂吗？因此需要增加合适的错误处理代码，来给予使用者给详细友善的提示。还有就是需要在一个统一的位置来处理所有错误，利人利己！

改进程序（增加模块化和错误处理）

分离main函数思路（启动与逻辑）

如何处理庞大的 main 函数，Rust 社区给出了统一的指导方案:

• 将程序分割为 main.rs 和 lib.rs，并将程序的逻辑代码移动到后者内
• 命令行解析属于非常基础的功能，严格来说不算是逻辑代码的一部分，因此还可以放在 main.rs 中

按照这个方案，将我们的代码重新梳理后，可以得出 main 函数应该包含的功能:

• 解析命令行参数
• 初始化其它配置
• 调用 lib.rs 中的 run 函数，以启动逻辑代码的运行
• 如果 run 返回一个错误，需要对该错误进行处理

这个方案有一个很优雅的名字: 关注点分离(Separation of Concerns)。简而言之，main.rs 负责启动程序，lib.rs 负责逻辑代码的运行。从测试的角度而言，这种分离也非常合理： lib.rs 中的主体逻辑代码可以得到简单且充分的测试，至于 main.rs ？确实没办法针对其编写额外的测试代码，但是它的代码也很少啊，很容易就能保证它的正确性。

分离main中命令解析

//in main.rsfn main() {    //将内容转换为数组集合    let args: Vec = env::args().collect();    //2.0，命令解析    let (query, file_path) = parse_config(&args);    //省略}// in main.rs//解析函数fn parse_config(args: &[String]) -> (&str,&str) {   let query = &args[1];   let file_path = &args[2];   (query,file_path)}

聚合配置变量

配置变量并不适合分散的到处都是，因此使用一个结构体来统一存放是非常好的选择，这样修改后，后续的使用以及未来的代码维护都将更加简单明了

//in main.rs//引入环境包，可以处理传入的参数use std::env;use std::fs;fn main() {    //将内容转换为数组集合    let args: Vec = env::args().collect();    //待搜查字符串    //存储文件路径    //let query = &args[1];    //let file_path = &args[2];    //2.0    let config = parse_config(&args);    println!("Searching for {}",config.query);    println!("In file {}",config.file_path);    //读取文件内容，记得异常处理    let context = fs::read_to_string(config.file_path)        .expect("Should have been able to read the file!");    //捕获变量    print!("With text:\n{context}");    //使用 dbg！宏，读取数组内容    //dbg!(args);}// in main.rs//聚合变量struct Config {    query:String,    file_path:String,}// 命令解析//这里选择clone, 防止所有权带来的问题fn parse_config(args: &[String]) -> Config {   let query = args[1].clone();   let file_path = args[2].clone();   Config {query,file_path}}

clone 的得与失在上面的代码中，除了使用 clone，还有其它办法来达成同样的目的，但 clone无疑是最简单的方法：直接完整的复制目标数据，无需被所有权、借用等问题所困扰，但是它也有其缺点，那就是有一定的性能损耗。因此是否使用 clone更多是一种性能上的权衡，对于上面的使用而言，由于是配置的初始化，因此整个程序只需要执行一次，性能损耗几乎是可以忽略不计的。总之，判断是否使用 clone:

• 是否严肃的项目，玩具项目直接用 clone就行，简单不好吗？
• 要看所在的代码路径是否是热点路径(hot path)，例如执行次数较多的显然就是热点路径，热点路径就值得去使用性能更好的实现方式

上面的代码总感觉差点意思，特别是从OO语言来的！目标：通过构造函数来初始化一个 Config 实例，而不是直接通过函数返回实例，典型的，标准库中的 String::new 函数就是一个范例。

//in main.rs//引入环境包，可以处理传入的参数use std::env;use std::fs;fn main() {    //将内容转换为数组集合    let args: Vec = env::args().collect();    //待搜查字符串    //存储文件路径    //let query = &args[1];    //let file_path = &args[2];    //2.0    //let config = parse_config(&args);    let config = Config::new(&args);    println!("Searching for {}", config.query);    println!("In file {}", config.file_path);    //读取文件内容，记得异常处理    let context =        fs::read_to_string(config.file_path).expect("Should have been able to read the file!");    //捕获变量    print!("With text:\n{context}");    //使用 dbg！宏，读取数组内容    //dbg!(args);}// in main.rs//聚合配置变量struct Config {    query: String,    file_path: String,}// 命令解析//这里选择clone, 防止所有权带来的问题/*fn parse_config(args: &[String]) -> Config {   let query = args[1].clone();   let file_path = args[2].clone();   Config {query,file_path}}*///修改为符合 OO 语言的构造impl Config {    fn new(args: &[String]) -> Config {        let query = args[1].clone();        let file_path = args[2].clone();        Config { query, file_path }    }}

错误处理

如果用户不输入任何命令行参数，我们的程序会怎么样？结果喜闻乐见，由于 args 数组没有任何元素，因此通过索引访问时，会直接报出数组访问越界的 panic。

想法一：主动调用panic

impl Config {    fn new(args: &[String]) -> Config {        //错误处理1：主动调用panic        if args.len( ) < 3 {            panic!("not enough arguments");        }        let query = args[1].clone();        let file_path = args[2].clone();        Config { query, file_path }    }}

用户看到了更为明确的提示，但是还是有一大堆 debug 输出，这些我们其实是不想让用户看到的。这么看来，想要输出对用户友好的信息, panic 是不太适合的，它更适合告知开发者，哪里出现了问题

想法二：返回Result来代替直接panic

new往往不会失败，毕竟新建一个实例没道理失败，对不？因此修改为build` 会更加合适。

//in main.rs//引入环境包，可以处理传入的参数use std::env;use std::fs;use std::process;fn main() {    //将内容转换为数组集合    let args: Vec = env::args().collect();    //待搜查字符串    //存储文件路径    //let query = &args[1];    //let file_path = &args[2];    //2.0    //let config = parse_config(&args);    //更加友好的错误处理    let config = Config::build(&args).unwrap_or_else(|err| {        println!("Problem parsing arguments: {err}");        process::exit(1);    });    println!("Searching for {}", config.query);    println!("In file {}", config.file_path);    //读取文件内容，记得异常处理    let context =        fs::read_to_string(config.file_path).expect("Should have been able to read the file!");    //捕获变量    print!("With text:\n{context}");    //使用 dbg！宏，读取数组内容    //dbg!(args);}// in main.rs//聚合配置变量struct Config {    query: String,    file_path: String,}// 命令解析//这里选择clone, 防止所有权带来的问题/*fn parse_config(args: &[String]) -> Config {   let query = args[1].clone();   let file_path = args[2].clone();   Config {query,file_path}}*///修改为符合 OO 语言的构造impl Config {                                  //标注生命周期，让闭包可以处理    fn build(args: &[String]) -> Result {        //错误处理1：主动调用panic        /*        if args.len( ) < 3 {            panic!("not enough arguments");        }        */        //错误处理2：返回Result来直接代替panic        if args.len() < 3 {            return Err("not enough arguments");        }        let query = args[1].clone();        let file_path = args[2].clone();        Ok(Config { query, file_path })    }}

• 当 Result 包含错误时，我们不再调用 panic 让程序崩溃，而是通过 process::exit(1) 来终结进程，其中 1 是一个信号值(事实上非 0 值都可以)，通知调用我们程序的进程，程序是因为错误而退出的。
• unwrap_or_else是定义在 Result 上的常用方法，如果 Result 是 Ok，那该方法就类似 unwrap：返回 Ok 内部的值；如果是 Err，就调用闭包中的自定义代码对错误进行进一步处理

分离主体逻辑

继续精简 main 函数，那就是将主体逻辑( 例如业务逻辑 )从 main 中分离出去，这样 main 函数就保留主流程调用，非常简洁。只负责解析命令。

注意：这里因为config直接由主体逻辑负责了，所以采用所有权进行转移。

fn main() {    //将内容转换为数组集合    let args: Vec = env::args().collect();    //待搜查字符串    //存储文件路径    //let query = &args[1];    //let file_path = &args[2];    //2.0    //let config = parse_config(&args);    //更加友好的错误处理    let config = Config::build(&args).unwrap_or_else(|err| {        println!("Problem parsing arguments: {err}");        process::exit(1);    });    println!("Searching for {}", config.query);    println!("In file {}", config.file_path);    run(config)    //使用 dbg！宏，读取数组内容    //dbg!(args);}//直接所有权转移fn run(config: Config) {    //读取文件内容，记得异常处理    let context =        fs::read_to_string(config.file_path).expect("Should have been able to read the file!");    //捕获变量    print!("With text:\n{context}");}

使用？和特征对象来返回错误

run` 函数没有错误处理，因为在文章开头我们提到过，错误处理最好统一在一个地方完成，这样极其有利于后续的代码维护。

//in main.rs//引入环境包，可以处理传入的参数use std::env;use std::error::Error;use std::fs;use std::process;fn main() {    //将内容转换为数组集合    let args: Vec = env::args().collect();    //待搜查字符串    //存储文件路径    //let query = &args[1];    //let file_path = &args[2];    //2.0    //let config = parse_config(&args);    //更加友好的错误处理    let config = Config::build(&args).unwrap_or_else(|err| {        println!("Problem parsing arguments: {err}");        process::exit(1);    });    println!("Searching for {}", config.query);    println!("In file {}", config.file_path);        //因为只需要匹配一个，用if let 进行匹配错误，不用match    if let Err(e) = run(config) {        println!("Application error: {e}");        process::exit(1);    }    //使用 dbg！宏，读取数组内容    //dbg!(args);}//直接所有权转移//Error是特征对象，引入包，dyn类型，动态，智能指针fn run(config: Config) -> Result<(), Box>{    //读取文件内容，记得异常处理    //使用 ？ 将otherError转换为returnError    let context =        fs::read_to_string(config.file_path)?;    //捕获变量    print!("With text:\n{context}");    Ok(())}// in main.rs//聚合配置变量struct Config {    query: String,    file_path: String,}// 命令解析//这里选择clone, 防止所有权带来的问题/*fn parse_config(args: &[String]) -> Config {   let query = args[1].clone();   let file_path = args[2].clone();   Config {query,file_path}}*///修改为符合 OO 语言的构造impl Config {    fn build(args: &[String]) -> Result {        //错误处理1：主动调用panic        /*        if args.len( ) < 3 {            panic!("not enough arguments");        }        */        //错误处理2：返回Result来直接代替panic        if args.len() < 3 {            return Err("not enough arguments");        }        let query = args[1].clone();        let file_path = args[2].clone();        Ok(Config { query, file_path })    }}

• Result的要求，因此使用了Ok(())返回一个单元类型()。最重要的是 Box， 如果按照顺序学到这里，大家应该知道这是一个Error 的特征对象(为了使用 Error，我们通过 use std::error::Error; 进行了引入)，它表示函数返回一个类型，该类型实现了 Error 特征，这样我们就无需指定具体的错误类型，否则你还需要查看。
• ？传播界的大明星
• 最后，用if let处理返回的错误，我们并不关注 run 返回的 Ok 值，因此只需要用 if let 去匹配是否存在错误即可。

分离逻辑代码到库包中

首先，创建一个 src/lib.rs 文件，然后将所有的非 main 函数都移动到其中。

记得：分离之后，要对库文件里的各个代码标记上权限等。

libc.rs

//引入到库包中，非main的代码use std::error::Error;use std::fs;//聚合配置变量pub struct Config {    pub query: String,    pub file_path: String,}// 命令解析//这里选择clone, 防止所有权带来的问题/*fn parse_config(args: &[String]) -> Config {   let query = args[1].clone();   let file_path = args[2].clone();   Config {query,file_path}}*///修改为符合 OO 语言的构造impl Config {    pub fn build(args: &[String]) -> Result {        //错误处理1：主动调用panic        /*        if args.len( ) < 3 {            panic!("not enough arguments");        }        */        //错误处理2：返回Result来直接代替panic        if args.len() < 3 {            return Err("not enough arguments");        }        let query = args[1].clone();        let file_path = args[2].clone();        Ok(Config { query, file_path })    }}//直接所有权转移//Error是特征对象，引入包，dyn类型，动态，智能指针pub fn run(config: Config) -> Result<(), Box>{    //读取文件内容，记得异常处理    //使用 ？ 将otherError转换为returnError    let context =        fs::read_to_string(config.file_path)?;    //捕获变量    print!("With text:\n{context}");    Ok(())}

main.rs

//in main.rs//引入环境包，可以处理传入的参数use std::env;use std::process;use minigrep::Config;fn main() {    //将内容转换为数组集合    let args: Vec = env::args().collect();    //待搜查字符串    //存储文件路径    //let query = &args[1];    //let file_path = &args[2];    //2.0    //let config = parse_config(&args);    //更加友好的错误处理    let config = Config::build(&args).unwrap_or_else(|err| {        println!("Problem parsing arguments: {err}");        process::exit(1);    });    println!("Searching for {}", config.query);    println!("In file {}", config.file_path);        //因为只需要匹配一个，用if let 进行匹配错误，不用match    if let Err(e) = minigrep::run(config) {        println!("Application error: {e}");        process::exit(1);    }    //使用 dbg！宏，读取数组内容    //dbg!(args);}

这里的 mingrep::run 的调用，以及 Config 的引入，跟使用其它第三方包已经没有任何区别，也意味着我们成功的将逻辑代码放置到一个独立的库包中，其它包只要引入和调用就行。

这里，lib.rs就是库，库的名就是项目名。本身也是一个包。

测试驱动开发

我们需要先编写一些测试代码，也是最近颇为流行的测试驱动开发模式(TDD, Test Driven Development)：

1. 编写一个注定失败的测试，并且失败的原因和你指定的一样
2. 编写一个成功的测试
3. 编写你的逻辑代码，直到通过测试

注定失败的用例

pub fn search<"a >(query: &str,contents: &"a str) -> Vec<&"a str> {    vec![]}#[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));    }}

$ cargo test   Compiling minigrep v0.1.0 (file:///projects/minigrep)    Finished test [unoptimized + debuginfo] target(s) in 0.97s     Running unittests src/lib.rs (target/debug/deps/minigrep-9cd200e5fac0fc94)running 1 testtest tests::one_result ... FAILEDfailures:---- tests::one_result stdout ----thread "main" panicked at "assertion failed: `(left == right)`  left: `["safe, fast, productive."]`, right: `[]`", src/lib.rs:44:9note: run with `RUST_BACKTRACE=1` environment variable to display a backtracefailures:    tests::one_resulttest result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00serror: test failed, to rerun pass `--lib`

注定成功的用例

pub fn search<"a >(query: &str,contents: &"a str) -> Vec<&"a str> {    //vec![] //注定失败的用例    let mut result = Vec::new();    for line in contents.lines() {        if line.contains(query) {            result.push(line);        }    }    result}

$ cargo test   Compiling minigrep v0.1.0 (file:///projects/minigrep)    Finished test [unoptimized + debuginfo] target(s) in 1.22s     Running unittests src/lib.rs (target/debug/deps/minigrep-9cd200e5fac0fc94)running 1 testtest tests::one_result ... oktest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s     Running unittests src/main.rs (target/debug/deps/minigrep-9cd200e5fac0fc94)running 0 teststest result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s   Doc-tests minigreprunning 0 teststest result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

在run函数中调用search函数

//直接所有权转移//Error是特征对象，引入包，dyn类型，动态，智能指针pub fn run(config: Config) -> Result<(), Box> {    //读取文件内容，记得异常处理    //使用 ？ 将otherError转换为returnError    let contents = fs::read_to_string(config.file_path)?;    //捕获变量    //print!("With text:\n{contents}");    for line in search(&config.query, &contents) {        println!("{line}");    }    Ok(())}

$ cargo run -- frog poem.txt   Compiling minigrep v0.1.0 (file:///projects/minigrep)    Finished dev [unoptimized + debuginfo] target(s) in 0.38s     Running `target/debug/minigrep frog poem.txt`How public, like a frog

使用环境变量来增强程序

在编译时候控制，如栈展开，大小写敏感

RUST_BACKTRACE=1 cargo run

IGNORE_CASE=1 cargo run -- to poem.txt

首先写一个注定失败

很简单，函数不要实现就好

写一个成功的案例

//大小写敏感pub fn search<"a >(query: &str,contents: &"a str) -> Vec<&"a str> {    //vec![] //注定失败的用例    let mut result = Vec::new();    for line in contents.lines() {        if line.contains(query) {            result.push(line);        }    }    result}//大小写不敏感pub fn search_case_insensitive<"a >(query: &str,contents: &"a str) -> Vec<&"a str> {    let query = query.to_lowercase();    let mut result = Vec::new();    for line in contents.lines() {        if line.to_lowercase().contains(&query) {            result.push(line);        }    }    result}#[cfg(test)]mod tests {    use super::*;        #[test] //标注为test    fn case_sensitive( ) {        let query = "duct";        let contents = "\Rust:safe, fast, productive.Pick three.Duct 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));    }}

环境控制大写与内部流程控制

//直接所有权转移//Error是特征对象，引入包，dyn类型，动态，智能指针pub fn run(config: Config) -> Result<(), Box> {    //读取文件内容，记得异常处理    //使用 ？ 将otherError转换为returnError    let contents = fs::read_to_string(config.file_path)?;    //捕获变量    //print!("With text:\n{contents}");    let results = if config.ignore_case {        search_case_insensitive(&config.query, &contents)     } else {        search(&config.query, &contents)    };    for line in results {        println!("{line}");    }    Ok(())}

//聚合配置变量pub struct Config {    pub query: String,    pub file_path: String,    pub ignore_case: bool,}

重定向错误信息的输出

无论 debug 还是 error 类型，都是通过 println! 宏输出到终端的标准输出( stdout )，但是对于程序来说，错误信息更适合输出到标准错误输出(stderr)。用户就可以选择将普通的日志类信息输出到日志文件 1，然后将错误信息输出到日志文件 2，甚至还可以输出到终端命令行。

结论：分离错误信息

如果错信息输出到标准输出，那么它们将跟普通的日志信息混在一起，难以分辨，因此我们需要将错误信息进行单独输出。

标准错误输出stderr

将错误信息和日志信息，在终端输出其他内容，在新的文件中出现很简单，将改为eprintln即可

fn main() {    //将内容转换为数组集合    let args: Vec = env::args().collect();    //待搜查字符串    //存储文件路径    //let query = &args[1];    //let file_path = &args[2];    //2.0    //let config = parse_config(&args);    //更加友好的错误处理    let config = Config::build(&args).unwrap_or_else(|err| {        eprintln!("Problem parsing arguments: {err}");        process::exit(1);    });    //println!("Searching for {}", config.query);    //println!("In file {}", config.file_path);        //因为只需要匹配一个，用if let 进行匹配错误，不用match    if let Err(e) = minigrep::run(config) {        eprintln!("Application error: {e}");        process::exit(1);    }    //使用 dbg！宏，读取数组内容    //dbg!(args);}

完结+迭代器修改

一些后续不再使用的，自己传入迭代器用迭代器去处理遍历，让语言变得更rusty

main.rs

//in main.rs//引入环境包，可以处理传入的参数use std::env;use std::process;use minigrep::Config;fn main() {    //将内容转换为数组集合    //let args: Vec = env::args().collect();    //待搜查字符串    //存储文件路径    //let query = &args[1];    //let file_path = &args[2];    //2.0    //let config = parse_config(&args);    //更加友好的错误处理    //这里直接传入迭代器即可    let config = Config::build(env::args()).unwrap_or_else(|err| {        eprintln!("Problem parsing arguments: {err}");        process::exit(1);    });    //println!("Searching for {}", config.query);    //println!("In file {}", config.file_path);        //因为只需要匹配一个，用if let 进行匹配错误，不用match    if let Err(e) = minigrep::run(config) {        eprintln!("Application error: {e}");        process::exit(1);    }    //使用 dbg！宏，读取数组内容    //dbg!(args);}

lib.rs

//引入到库包中，非main的代码use std::error::Error;use std::fs;use std::env;//聚合配置变量pub struct Config {    pub query: String,    pub file_path: String,    pub ignore_case: bool,}// 命令解析//这里选择clone, 防止所有权带来的问题/*fn parse_config(args: &[String]) -> Config {   let query = args[1].clone();   let file_path = args[2].clone();   Config {query,file_path}}*///修改为符合 OO 语言的构造impl Config {    //由于修改了clone，所以这里要修改    //而且移除索引    pub fn build(mut args : impl Iterator) -> Result {        //错误处理1：主动调用panic        /*        if args.len( ) < 3 {            panic!("not enough arguments");        }        */        //错误处理2：返回Result来直接代替panic        /*         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 file_path = match args.next() {            Some(arg) => arg,            None => return Err("Didn"t get a file path")        };        let ignore_case = env::var("IGNORE_CASE").is_ok();                //let query = args[1].clone();        //let file_path = args[2].clone();        //klet ignore_case = env::var("IGNORE_CASE").is_ok();        Ok(Config { query, file_path , ignore_case})    }}//直接所有权转移//Error是特征对象，引入包，dyn类型，动态，智能指针pub fn run(config: Config) -> Result<(), Box> {    //读取文件内容，记得异常处理    //使用 ？ 将otherError转换为returnError    let contents = fs::read_to_string(config.file_path)?;    //捕获变量    //print!("With text:\n{contents}");    let results = if config.ignore_case {        search_case_insensitive(&config.query, &contents)     } else {        search(&config.query, &contents)    };    for line in results {        println!("{line}");    }    Ok(())}//大小写敏感pub fn search<"a >(query: &str,contents: &"a str) -> Vec<&"a str> {    //vec![] //注定失败的用例    /*     let mut result = Vec::new();    for line in contents.lines() {        if line.contains(query) {            result.push(line);        }    }    result    */    contents        .lines()        .filter(|line| line.contains(query))        .collect()}//大小写不敏感pub fn search_case_insensitive<"a >(query: &str,contents: &"a str) -> Vec<&"a str> {    let query = query.to_lowercase();    /*    let mut result = Vec::new();    for line in contents.lines() {        if line.to_lowercase().contains(&query) {            result.push(line);        }    }    result    */    contents        .lines()        .filter(|line| line.to_lowercase().contains(query.as_str()))        .collect()}#[cfg(test)]mod tests {    use super::*;        #[test] //标注为test    fn case_sensitive( ) {        let query = "duct";        let contents = "\Rust:safe, fast, productive.Pick three.Duct 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));    }}

测试数据

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!传遍整个无聊的沼泽！