改进 I/O 项目

ch13-03-improving-our-io-project.md
commit cc958ca579816ea6ac7e9067d628b0423a1ed3e4

有了这些关于迭代器的新知识,我们可以使用迭代器来改进第十二章中 I/O 项目的实现来使得代码更简洁明了。让我们看看迭代器如何能够改进 Config::new 函数和 search 函数的实现。

使用迭代器并去掉 clone

在示例 12-6 中,我们增加了一些代码获取一个 String slice 并创建一个 Config 结构体的实例,他们索引 slice 中的值并克隆这些值以便 Config 结构体可以拥有这些值。在示例 13-24 中重现了第十二章结尾示例 12-23 中 Config::new 函数的实现:

文件名: src/lib.rs

  1. use std::env;
  2. use std::error::Error;
  3. use std::fs;
  4. pub struct Config {
  5. pub query: String,
  6. pub filename: String,
  7. pub case_sensitive: bool,
  8. }
  9. impl Config {
  10. pub fn new(args: &[String]) -> Result<Config, &'static str> {
  11. if args.len() < 3 {
  12. return Err("not enough arguments");
  13. }
  14. let query = args[1].clone();
  15. let filename = args[2].clone();
  16. let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
  17. Ok(Config {
  18. query,
  19. filename,
  20. case_sensitive,
  21. })
  22. }
  23. }
  24. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
  25. let contents = fs::read_to_string(config.filename)?;
  26. let results = if config.case_sensitive {
  27. search(&config.query, &contents)
  28. } else {
  29. search_case_insensitive(&config.query, &contents)
  30. };
  31. for line in results {
  32. println!("{}", line);
  33. }
  34. Ok(())
  35. }
  36. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  37. let mut results = Vec::new();
  38. for line in contents.lines() {
  39. if line.contains(query) {
  40. results.push(line);
  41. }
  42. }
  43. results
  44. }
  45. pub fn search_case_insensitive<'a>(
  46. query: &str,
  47. contents: &'a str,
  48. ) -> Vec<&'a str> {
  49. let query = query.to_lowercase();
  50. let mut results = Vec::new();
  51. for line in contents.lines() {
  52. if line.to_lowercase().contains(&query) {
  53. results.push(line);
  54. }
  55. }
  56. results
  57. }
  58. #[cfg(test)]
  59. mod tests {
  60. use super::*;
  61. #[test]
  62. fn case_sensitive() {
  63. let query = "duct";
  64. let contents = "\
  65. Rust:
  66. safe, fast, productive.
  67. Pick three.
  68. Duct tape.";
  69. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  70. }
  71. #[test]
  72. fn case_insensitive() {
  73. let query = "rUsT";
  74. let contents = "\
  75. Rust:
  76. safe, fast, productive.
  77. Pick three.
  78. Trust me.";
  79. assert_eq!(
  80. vec!["Rust:", "Trust me."],
  81. search_case_insensitive(query, contents)
  82. );
  83. }
  84. }

示例 13-24:重现第十二章结尾的 Config::new 函数

那时我们说过不必担心低效的 clone 调用了,因为将来可以对他们进行改进。好吧,就是现在!

起初这里需要 clone 的原因是参数 args 中有一个 String 元素的 slice,而 new 函数并不拥有 args。为了能够返回 Config 实例的所有权,我们需要克隆 Config 中字段 queryfilename 的值,这样 Config 实例就能拥有这些值。

在学习了迭代器之后,我们可以将 new 函数改为获取一个有所有权的迭代器作为参数而不是借用 slice。我们将使用迭代器功能之前检查 slice 长度和索引特定位置的代码。这会明确 Config::new 的工作因为迭代器会负责访问这些值。

一旦 Config::new 获取了迭代器的所有权并不再使用借用的索引操作,就可以将迭代器中的 String 值移动到 Config 中,而不是调用 clone 分配新的空间。

直接使用 env::args 返回的迭代器

打开 I/O 项目的 src/main.rs 文件,它看起来应该像这样:

文件名: src/main.rs

  1. use std::env;
  2. use std::process;
  3. use minigrep::Config;
  4. fn main() {
  5. let args: Vec<String> = env::args().collect();
  6. let config = Config::new(&args).unwrap_or_else(|err| {
  7. eprintln!("Problem parsing arguments: {}", err);
  8. process::exit(1);
  9. });
  10. // --snip--
  11. if let Err(e) = minigrep::run(config) {
  12. eprintln!("Application error: {}", e);
  13. process::exit(1);
  14. }
  15. }

修改第十二章结尾示例 12-24 中的 main 函数的开头为示例 13-25 中的代码。在更新 Config::new 之前这些代码还不能编译:

文件名: src/main.rs

  1. use std::env;
  2. use std::process;
  3. use minigrep::Config;
  4. fn main() {
  5. let config = Config::new(env::args()).unwrap_or_else(|err| {
  6. eprintln!("Problem parsing arguments: {}", err);
  7. process::exit(1);
  8. });
  9. // --snip--
  10. if let Err(e) = minigrep::run(config) {
  11. eprintln!("Application error: {}", e);
  12. process::exit(1);
  13. }
  14. }

示例 13-25:将 env::args 的返回值传递给 Config::new

env::args 函数返回一个迭代器!不同于将迭代器的值收集到一个 vector 中接着传递一个 slice 给 Config::new,现在我们直接将 env::args 返回的迭代器的所有权传递给 Config::new

接下来需要更新 Config::new 的定义。在 I/O 项目的 src/lib.rs 中,将 Config::new 的签名改为如示例 13-26 所示。这仍然不能编译因为我们还需更新函数体:

文件名: src/lib.rs

  1. use std::env;
  2. use std::error::Error;
  3. use std::fs;
  4. pub struct Config {
  5. pub query: String,
  6. pub filename: String,
  7. pub case_sensitive: bool,
  8. }
  9. impl Config {
  10. pub fn new(mut args: env::Args) -> Result<Config, &'static str> {
  11. // --snip--
  12. if args.len() < 3 {
  13. return Err("not enough arguments");
  14. }
  15. let query = args[1].clone();
  16. let filename = args[2].clone();
  17. let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
  18. Ok(Config {
  19. query,
  20. filename,
  21. case_sensitive,
  22. })
  23. }
  24. }
  25. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
  26. let contents = fs::read_to_string(config.filename)?;
  27. let results = if config.case_sensitive {
  28. search(&config.query, &contents)
  29. } else {
  30. search_case_insensitive(&config.query, &contents)
  31. };
  32. for line in results {
  33. println!("{}", line);
  34. }
  35. Ok(())
  36. }
  37. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  38. let mut results = Vec::new();
  39. for line in contents.lines() {
  40. if line.contains(query) {
  41. results.push(line);
  42. }
  43. }
  44. results
  45. }
  46. pub fn search_case_insensitive<'a>(
  47. query: &str,
  48. contents: &'a str,
  49. ) -> Vec<&'a str> {
  50. let query = query.to_lowercase();
  51. let mut results = Vec::new();
  52. for line in contents.lines() {
  53. if line.to_lowercase().contains(&query) {
  54. results.push(line);
  55. }
  56. }
  57. results
  58. }
  59. #[cfg(test)]
  60. mod tests {
  61. use super::*;
  62. #[test]
  63. fn case_sensitive() {
  64. let query = "duct";
  65. let contents = "\
  66. Rust:
  67. safe, fast, productive.
  68. Pick three.
  69. Duct tape.";
  70. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  71. }
  72. #[test]
  73. fn case_insensitive() {
  74. let query = "rUsT";
  75. let contents = "\
  76. Rust:
  77. safe, fast, productive.
  78. Pick three.
  79. Trust me.";
  80. assert_eq!(
  81. vec!["Rust:", "Trust me."],
  82. search_case_insensitive(query, contents)
  83. );
  84. }
  85. }

示例 13-26:以迭代器作为参数更新 Config::new 的签名

env::args 函数的标准库文档显示,它返回的迭代器的类型为 std::env::Args。我们已经更新了 Config :: new 函数的签名,因此参数 args 的类型为 std::env::Args 而不是 &[String]。因为我们拥有 args 的所有权,并且将通过对其进行迭代来改变 args ,所以我们可以将 mut 关键字添加到 args 参数的规范中以使其可变。

使用 Iterator trait 代替索引

接下来,我们将修改 Config::new 的内容。标准库文档还提到 std::env::Args 实现了 Iterator trait,因此我们知道可以对其调用 next 方法!示例 13-27 更新了示例 12-23 中的代码,以使用 next 方法:

文件名: src/lib.rs

  1. use std::env;
  2. use std::error::Error;
  3. use std::fs;
  4. pub struct Config {
  5. pub query: String,
  6. pub filename: String,
  7. pub case_sensitive: bool,
  8. }
  9. impl Config {
  10. pub fn new(mut args: env::Args) -> Result<Config, &'static str> {
  11. args.next();
  12. let query = match args.next() {
  13. Some(arg) => arg,
  14. None => return Err("Didn't get a query string"),
  15. };
  16. let filename = match args.next() {
  17. Some(arg) => arg,
  18. None => return Err("Didn't get a file name"),
  19. };
  20. let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
  21. Ok(Config {
  22. query,
  23. filename,
  24. case_sensitive,
  25. })
  26. }
  27. }
  28. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
  29. let contents = fs::read_to_string(config.filename)?;
  30. let results = if config.case_sensitive {
  31. search(&config.query, &contents)
  32. } else {
  33. search_case_insensitive(&config.query, &contents)
  34. };
  35. for line in results {
  36. println!("{}", line);
  37. }
  38. Ok(())
  39. }
  40. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  41. let mut results = Vec::new();
  42. for line in contents.lines() {
  43. if line.contains(query) {
  44. results.push(line);
  45. }
  46. }
  47. results
  48. }
  49. pub fn search_case_insensitive<'a>(
  50. query: &str,
  51. contents: &'a str,
  52. ) -> Vec<&'a str> {
  53. let query = query.to_lowercase();
  54. let mut results = Vec::new();
  55. for line in contents.lines() {
  56. if line.to_lowercase().contains(&query) {
  57. results.push(line);
  58. }
  59. }
  60. results
  61. }
  62. #[cfg(test)]
  63. mod tests {
  64. use super::*;
  65. #[test]
  66. fn case_sensitive() {
  67. let query = "duct";
  68. let contents = "\
  69. Rust:
  70. safe, fast, productive.
  71. Pick three.
  72. Duct tape.";
  73. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  74. }
  75. #[test]
  76. fn case_insensitive() {
  77. let query = "rUsT";
  78. let contents = "\
  79. Rust:
  80. safe, fast, productive.
  81. Pick three.
  82. Trust me.";
  83. assert_eq!(
  84. vec!["Rust:", "Trust me."],
  85. search_case_insensitive(query, contents)
  86. );
  87. }
  88. }

示例 13-27:修改 Config::new 的函数体来使用迭代器方法

请记住 env::args 返回值的第一个值是程序的名称。我们希望忽略它并获取下一个值,所以首先调用 next 并不对返回值做任何操作。之后对希望放入 Config 中字段 query 调用 next。如果 next 返回 Some,使用 match 来提取其值。如果它返回 None,则意味着没有提供足够的参数并通过 Err 值提早返回。对 filename 值进行同样的操作。

使用迭代器适配器来使代码更简明

I/O 项目中其他可以利用迭代器的地方是 search 函数,示例 13-28 中重现了第十二章结尾示例 12-19 中此函数的定义:

文件名: src/lib.rs

  1. use std::error::Error;
  2. use std::fs;
  3. pub struct Config {
  4. pub query: String,
  5. pub filename: String,
  6. }
  7. impl Config {
  8. pub fn new(args: &[String]) -> Result<Config, &'static str> {
  9. if args.len() < 3 {
  10. return Err("not enough arguments");
  11. }
  12. let query = args[1].clone();
  13. let filename = args[2].clone();
  14. Ok(Config { query, filename })
  15. }
  16. }
  17. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
  18. let contents = fs::read_to_string(config.filename)?;
  19. Ok(())
  20. }
  21. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  22. let mut results = Vec::new();
  23. for line in contents.lines() {
  24. if line.contains(query) {
  25. results.push(line);
  26. }
  27. }
  28. results
  29. }
  30. #[cfg(test)]
  31. mod tests {
  32. use super::*;
  33. #[test]
  34. fn one_result() {
  35. let query = "duct";
  36. let contents = "\
  37. Rust:
  38. safe, fast, productive.
  39. Pick three.";
  40. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  41. }
  42. }

示例 13-28:示例 12-19 中 search 函数的定义

可以通过使用迭代器适配器方法来编写更简明的代码。这也避免了一个可变的中间 results vector 的使用。函数式编程风格倾向于最小化可变状态的数量来使代码更简洁。去掉可变状态可能会使得将来进行并行搜索的增强变得更容易,因为我们不必管理 results vector 的并发访问。示例 13-29 展示了该变化:

文件名: src/lib.rs

  1. use std::env;
  2. use std::error::Error;
  3. use std::fs;
  4. pub struct Config {
  5. pub query: String,
  6. pub filename: String,
  7. pub case_sensitive: bool,
  8. }
  9. impl Config {
  10. pub fn new(mut args: std::env::Args) -> Result<Config, &'static str> {
  11. args.next();
  12. let query = match args.next() {
  13. Some(arg) => arg,
  14. None => return Err("Didn't get a query string"),
  15. };
  16. let filename = match args.next() {
  17. Some(arg) => arg,
  18. None => return Err("Didn't get a file name"),
  19. };
  20. let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
  21. Ok(Config {
  22. query,
  23. filename,
  24. case_sensitive,
  25. })
  26. }
  27. }
  28. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
  29. let contents = fs::read_to_string(config.filename)?;
  30. let results = if config.case_sensitive {
  31. search(&config.query, &contents)
  32. } else {
  33. search_case_insensitive(&config.query, &contents)
  34. };
  35. for line in results {
  36. println!("{}", line);
  37. }
  38. Ok(())
  39. }
  40. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  41. contents
  42. .lines()
  43. .filter(|line| line.contains(query))
  44. .collect()
  45. }
  46. pub fn search_case_insensitive<'a>(
  47. query: &str,
  48. contents: &'a str,
  49. ) -> Vec<&'a str> {
  50. let query = query.to_lowercase();
  51. let mut results = Vec::new();
  52. for line in contents.lines() {
  53. if line.to_lowercase().contains(&query) {
  54. results.push(line);
  55. }
  56. }
  57. results
  58. }
  59. #[cfg(test)]
  60. mod tests {
  61. use super::*;
  62. #[test]
  63. fn case_sensitive() {
  64. let query = "duct";
  65. let contents = "\
  66. Rust:
  67. safe, fast, productive.
  68. Pick three.
  69. Duct tape.";
  70. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  71. }
  72. #[test]
  73. fn case_insensitive() {
  74. let query = "rUsT";
  75. let contents = "\
  76. Rust:
  77. safe, fast, productive.
  78. Pick three.
  79. Trust me.";
  80. assert_eq!(
  81. vec!["Rust:", "Trust me."],
  82. search_case_insensitive(query, contents)
  83. );
  84. }
  85. }

示例 13-29:在 search 函数实现中使用迭代器适配器

回忆 search 函数的目的是返回所有 contents 中包含 query 的行。类似于示例 13-19 中的 filter 例子,可以使用 filter 适配器只保留 line.contains(query) 返回 true 的那些行。接着使用 collect 将匹配行收集到另一个 vector 中。这样就容易多了!尝试对 search_case_insensitive 函数做出同样的使用迭代器方法的修改吧。

接下来的逻辑问题就是在代码中应该选择哪种风格:是使用示例 13-28 中的原始实现还是使用示例 13-29 中使用迭代器的版本?大部分 Rust 程序员倾向于使用迭代器风格。开始这有点难以理解,不过一旦你对不同迭代器的工作方式有了感觉之后,迭代器可能会更容易理解。相比摆弄不同的循环并创建新 vector,(迭代器)代码则更关注循环的目的。这抽象掉那些老生常谈的代码,这样就更容易看清代码所特有的概念,比如迭代器中每个元素必须面对的过滤条件。

不过这两种实现真的完全等同吗?直觉上的假设是更底层的循环会更快一些。让我们聊聊性能吧。