我的书签
添加书签
移除书签改进 I/O 项目
ch13-03-improving-our-io-project.md commit 2cd1b5593d26dc6a03c20f8619187ad4b2485552
掌握了这些关于迭代器的新知识后，我们可以使用迭代器来改进第十二章中 I/O 项目的实现来使得代码更简洁明了。接下来，让我们看看迭代器如何改进 Config::build 函数和 search 函数的实现。
使用迭代器去除 clone
在示例 12-6 中，我们增加了一些代码获取一个 String 类型的 slice 并创建一个 Config 结构体的实例，它们索引 slice 中的值并克隆这些值以便 Config 结构体可以拥有这些值。在示例 13-17 中重现了第十二章结尾示例 12-23 中 Config::build 函数的实现：
文件名：src/lib.rs
1. use std::env;
2. use std::error::Error;
3. use std::fs;
5. pub struct Config {
6. pub query: String,
7. pub file_path: String,
8. pub ignore_case: bool,
9. }
11. impl Config {
12. pub fn build(args: &[String]) -> Result<Config, &'static str> {
13. if args.len() < 3 {
14. return Err("not enough arguments");
15. }
17. let query = args[1].clone();
18. let file_path = args[2].clone();
20. let ignore_case = env::var("IGNORE_CASE").is_ok();
22. Ok(Config {
23. query,
24. file_path,
25. ignore_case,
26. })
27. }
28. }
30. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
31. let contents = fs::read_to_string(config.file_path)?;
33. let results = if config.ignore_case {
34. search_case_insensitive(&config.query, &contents)
35. } else {
36. search(&config.query, &contents)
37. };
39. for line in results {
40. println!("{line}");
41. }
43. Ok(())
44. }
46. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
47. let mut results = Vec::new();
49. for line in contents.lines() {
50. if line.contains(query) {
51. results.push(line);
52. }
53. }
55. results
56. }
58. pub fn search_case_insensitive<'a>(
59. query: &str,
60. contents: &'a str,
61. ) -> Vec<&'a str> {
62. let query = query.to_lowercase();
63. let mut results = Vec::new();
65. for line in contents.lines() {
66. if line.to_lowercase().contains(&query) {
67. results.push(line);
68. }
69. }
71. results
72. }
74. #[cfg(test)]
75. mod tests {
76. use super::*;
78. #[test]
79. fn case_sensitive() {
80. let query = "duct";
81. let contents = "\
82. Rust:
83. safe, fast, productive.
84. Pick three.
85. Duct tape.";
87. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
88. }
90. #[test]
91. fn case_insensitive() {
92. let query = "rUsT";
93. let contents = "\
94. Rust:
95. safe, fast, productive.
96. Pick three.
97. Trust me.";
99. assert_eq!(
100. vec!["Rust:", "Trust me."],
101. search_case_insensitive(query, contents)
102. );
103. }
104. }
示例 13-17：重现示例 12-23 的 Config::build 函数
当时我们说过不必担心低效的 clone 调用，因为我们以后会将其移除。好吧，就是现在！
起初这里需要 clone 的原因是参数 args 中有一个 String 元素的 slice，而 build 函数并不拥有 args。为了能够返回 Config 实例的所有权，我们需要克隆 Config 中字段 query 和 file_path 的值，这样 Config 实例就能拥有这些值。
在学习了迭代器之后，我们可以将 build 函数改为获取一个有所有权的迭代器作为参数，而不是借用 slice。我们将使用迭代器功能代替之前检查 slice 长度和索引特定位置的代码。这样可以更清晰地表达 Config::build 函数的操作，因为迭代器会负责访问这些值。
一旦 Config::build 获取了迭代器的所有权并不再使用借用的索引操作，就可以将迭代器中的 String 值移动到 Config 中，而不是调用 clone 分配新的空间。
直接使用返回的迭代器
打开 I/O 项目的 src/main.rs 文件，它看起来应该像这样：
文件名：src/main.rs
1. use std::env;
2. use std::process;
4. use minigrep::Config;
6. fn main() {
7. let args: Vec<String> = env::args().collect();
9. let config = Config::build(&args).unwrap_or_else(|err| {
10. eprintln!("Problem parsing arguments: {err}");
11. process::exit(1);
12. });
14. // --snip--
16. if let Err(e) = minigrep::run(config) {
17. eprintln!("Application error: {e}");
18. process::exit(1);
19. }
20. }
首先我们修改第十二章结尾示例 12-24 中的 main 函数的开头为示例 13-18 中的代码。在更新 Config::build 之前这些代码还不能编译：
文件名：src/main.rs
1. use std::env;
2. use std::process;
4. use minigrep::Config;
6. fn main() {
7. let config = Config::build(env::args()).unwrap_or_else(|err| {
8. eprintln!("Problem parsing arguments: {err}");
9. process::exit(1);
10. });
12. // --snip--
14. if let Err(e) = minigrep::run(config) {
15. eprintln!("Application error: {e}");
16. process::exit(1);
17. }
18. }
示例 13-25：将 env::args 的返回值传递给 Config::build
env::args 函数返回一个迭代器！不同于将迭代器的值收集到一个 vector 中接着传递一个 slice 给 Config::build，现在我们直接将 env::args 返回的迭代器的所有权传递给 Config::build。
接下来需要更新 Config::build 的定义。在 I/O 项目的 src/lib.rs 中，将 Config::build 的签名改为如示例 13-19 所示。这仍然不能编译因为我们还需更新函数体。
文件名：src/lib.rs
1. use std::env;
2. use std::error::Error;
3. use std::fs;
5. pub struct Config {
6. pub query: String,
7. pub file_path: String,
8. pub ignore_case: bool,
9. }
11. impl Config {
12. pub fn build(
13. mut args: impl Iterator<Item = String>,
14. ) -> Result<Config, &'static str> {
15. // --snip--
16. if args.len() < 3 {
17. return Err("not enough arguments");
18. }
20. let query = args[1].clone();
21. let file_path = args[2].clone();
23. let ignore_case = env::var("IGNORE_CASE").is_ok();
25. Ok(Config {
26. query,
27. file_path,
28. ignore_case,
29. })
30. }
31. }
33. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
34. let contents = fs::read_to_string(config.file_path)?;
36. let results = if config.ignore_case {
37. search_case_insensitive(&config.query, &contents)
38. } else {
39. search(&config.query, &contents)
40. };
42. for line in results {
43. println!("{line}");
44. }
46. Ok(())
47. }
49. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
50. let mut results = Vec::new();
52. for line in contents.lines() {
53. if line.contains(query) {
54. results.push(line);
55. }
56. }
58. results
59. }
61. pub fn search_case_insensitive<'a>(
62. query: &str,
63. contents: &'a str,
64. ) -> Vec<&'a str> {
65. let query = query.to_lowercase();
66. let mut results = Vec::new();
68. for line in contents.lines() {
69. if line.to_lowercase().contains(&query) {
70. results.push(line);
71. }
72. }
74. results
75. }
77. #[cfg(test)]
78. mod tests {
79. use super::*;
81. #[test]
82. fn case_sensitive() {
83. let query = "duct";
84. let contents = "\
85. Rust:
86. safe, fast, productive.
87. Pick three.
88. Duct tape.";
90. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
91. }
93. #[test]
94. fn case_insensitive() {
95. let query = "rUsT";
96. let contents = "\
97. Rust:
98. safe, fast, productive.
99. Pick three.
100. Trust me.";
102. assert_eq!(
103. vec!["Rust:", "Trust me."],
104. search_case_insensitive(query, contents)
105. );
106. }
107. }
示例 13-19：以迭代器作为参数更新 Config::build 的签名
env::args 函数的标准库文档显示，它返回的迭代器的类型为 std::env::Args，并且这个类型实现了 Iterator trait 并返回 String 值。
我们已经更新了 Config::build 函数的签名，因此参数 args 有一个带有 trait bounds impl Iterator<Item = String> 的泛型类型，而不是 &[String]。这里用到了第十章 “trait 作为参数” 部分讨论过的 impl Trait 语法，这意味着 args 可以是任何实现了 Iterator trait 并返回 String 项（item）的类型。
由于我们获取了 args 的所有权，并且将通过迭代来修改 args，因此我们可以在 args 参数的声明中添加 mut 关键字，使其可变。
使用 Iterator trait 代替索引
接下来，我们将修改 Config::build 的函数体。因为 args 实现了 Iterator trait，因此我们知道可以对其调用 next 方法！示例 13-20 更新了示例 12-23 中的代码，以使用 next 方法：
文件名：src/lib.rs
1. use std::env;
2. use std::error::Error;
3. use std::fs;
5. pub struct Config {
6. pub query: String,
7. pub file_path: String,
8. pub ignore_case: bool,
9. }
11. impl Config {
12. pub fn build(
13. mut args: impl Iterator<Item = String>,
14. ) -> Result<Config, &'static str> {
15. args.next();
17. let query = match args.next() {
18. Some(arg) => arg,
19. None => return Err("Didn't get a query string"),
20. };
22. let file_path = match args.next() {
23. Some(arg) => arg,
24. None => return Err("Didn't get a file path"),
25. };
27. let ignore_case = env::var("IGNORE_CASE").is_ok();
29. Ok(Config {
30. query,
31. file_path,
32. ignore_case,
33. })
34. }
35. }
37. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
38. let contents = fs::read_to_string(config.file_path)?;
40. let results = if config.ignore_case {
41. search_case_insensitive(&config.query, &contents)
42. } else {
43. search(&config.query, &contents)
44. };
46. for line in results {
47. println!("{line}");
48. }
50. Ok(())
51. }
53. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
54. let mut results = Vec::new();
56. for line in contents.lines() {
57. if line.contains(query) {
58. results.push(line);
59. }
60. }
62. results
63. }
65. pub fn search_case_insensitive<'a>(
66. query: &str,
67. contents: &'a str,
68. ) -> Vec<&'a str> {
69. let query = query.to_lowercase();
70. let mut results = Vec::new();
72. for line in contents.lines() {
73. if line.to_lowercase().contains(&query) {
74. results.push(line);
75. }
76. }
78. results
79. }
81. #[cfg(test)]
82. mod tests {
83. use super::*;
85. #[test]
86. fn case_sensitive() {
87. let query = "duct";
88. let contents = "\
89. Rust:
90. safe, fast, productive.
91. Pick three.
92. Duct tape.";
94. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
95. }
97. #[test]
98. fn case_insensitive() {
99. let query = "rUsT";
100. let contents = "\
101. Rust:
102. safe, fast, productive.
103. Pick three.
104. Trust me.";
106. assert_eq!(
107. vec!["Rust:", "Trust me."],
108. search_case_insensitive(query, contents)
109. );
110. }
111. }
示例 13-20：修改 Config::build 的函数体来使用迭代器方法
请记住 env::args 返回值的第一个值是程序的名称。我们希望忽略它并获取下一个值，所以首先调用 next 且不对其返回值做任何操作。然后，我们再次调用 next 来获取要放入 Config 结构体的 query 字段的值。如果 next 返回 Some，使用 match 来提取其值。如果它返回 None，则意味着没有提供足够的参数并通过 Err 值提早返回。我们对对 file_path 的值也进行同样的操作。
使用迭代器适配器来使代码更简明
I/O 项目中其他可以利用迭代器的地方是 search 函数，示例 13-21 中重现了第十二章结尾示例 12-19 中此函数的定义：
文件名：src/lib.rs
1. use std::error::Error;
2. use std::fs;
4. pub struct Config {
5. pub query: String,
6. pub file_path: String,
7. }
9. impl Config {
10. pub fn build(args: &[String]) -> Result<Config, &'static str> {
11. if args.len() < 3 {
12. return Err("not enough arguments");
13. }
15. let query = args[1].clone();
16. let file_path = args[2].clone();
18. Ok(Config { query, file_path })
19. }
20. }
22. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
23. let contents = fs::read_to_string(config.file_path)?;
25. Ok(())
26. }
28. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
29. let mut results = Vec::new();
31. for line in contents.lines() {
32. if line.contains(query) {
33. results.push(line);
34. }
35. }
37. results
38. }
40. #[cfg(test)]
41. mod tests {
42. use super::*;
44. #[test]
45. fn one_result() {
46. let query = "duct";
47. let contents = "\
48. Rust:
49. safe, fast, productive.
50. Pick three.";
52. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
53. }
54. }
示例 13-21：示例 12-19 中 search 函数的定义
可以通过使用迭代器适配器方法来编写更简明的代码。这样做还可以避免使用一个可变的中间 results vector。函数式编程风格倾向于最小化可变状态的数量来使代码更简洁。去除可变状态可能会使未来的并行搜索优化变得更容易，因为我们不必管理对 results vector 的并发访问。示例 13-22 展示了这一变化：
文件名：src/lib.rs
1. use std::env;
2. use std::error::Error;
3. use std::fs;
5. pub struct Config {
6. pub query: String,
7. pub file_path: String,
8. pub ignore_case: bool,
9. }
11. impl Config {
12. pub fn build(
13. mut args: impl Iterator<Item = String>,
14. ) -> Result<Config, &'static str> {
15. args.next();
17. let query = match args.next() {
18. Some(arg) => arg,
19. None => return Err("Didn't get a query string"),
20. };
22. let file_path = match args.next() {
23. Some(arg) => arg,
24. None => return Err("Didn't get a file path"),
25. };
27. let ignore_case = env::var("IGNORE_CASE").is_ok();
29. Ok(Config {
30. query,
31. file_path,
32. ignore_case,
33. })
34. }
35. }
37. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
38. let contents = fs::read_to_string(config.file_path)?;
40. let results = if config.ignore_case {
41. search_case_insensitive(&config.query, &contents)
42. } else {
43. search(&config.query, &contents)
44. };
46. for line in results {
47. println!("{line}");
48. }
50. Ok(())
51. }
53. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
54. contents
55. .lines()
56. .filter(|line| line.contains(query))
57. .collect()
58. }
60. pub fn search_case_insensitive<'a>(
61. query: &str,
62. contents: &'a str,
63. ) -> Vec<&'a str> {
64. let query = query.to_lowercase();
65. let mut results = Vec::new();
67. for line in contents.lines() {
68. if line.to_lowercase().contains(&query) {
69. results.push(line);
70. }
71. }
73. results
74. }
76. #[cfg(test)]
77. mod tests {
78. use super::*;
80. #[test]
81. fn case_sensitive() {
82. let query = "duct";
83. let contents = "\
84. Rust:
85. safe, fast, productive.
86. Pick three.
87. Duct tape.";
89. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
90. }
92. #[test]
93. fn case_insensitive() {
94. let query = "rUsT";
95. let contents = "\
96. Rust:
97. safe, fast, productive.
98. Pick three.
99. Trust me.";
101. assert_eq!(
102. vec!["Rust:", "Trust me."],
103. search_case_insensitive(query, contents)
104. );
105. }
106. }
示例 13-22：在 search 函数实现中使用迭代器适配器
回忆一下，search 函数的目的是返回所有 contents 中包含 query 的行。类似于示例 13-16 中的 filter 例子，这段代码使用 filter 适配器来保留 line.contains(query) 返回 true 的行。接着使用 collect 将匹配行收集到另一个 vector 中。这样就容易多了！尝试对 search_case_insensitive 函数做出同样的使用迭代器方法的修改吧。
选择循环或迭代器
接下来的逻辑问题就是在代码中应该选择哪种风格，以及原因：是使用示例 13-21 中的原始实现还是使用示例 13-22 中使用迭代器的版本？大部分 Rust 程序员倾向于使用迭代器风格。开始这有点难以掌握，不过一旦你对不同迭代器的工作方式有了感觉之后，迭代器反而更容易理解。相比摆弄不同的循环并创建新 vector，（迭代器）代码则更关注循环的高层次目的。这抽象掉那些老生常谈的代码，这样就更容易看清代码所特有的概念，比如迭代器中每个元素必须满足的过滤条件。
不过这两种实现真的完全等价吗？直觉上的假设是更底层的循环会更快一些。让我们聊聊性能吧。
