我的书签
添加书签
移除书签处理环境变量
ch12-05-working-with-environment-variables.md
commit 9c0fa2714859738ff73cbbb829592e4c037d7e46
我们将增加一个额外的功能来改进 minigrep：用户可以通过设置环境变量来设置搜索是否是大小写敏感的 。当然，我们也可以将其设计为一个命令行参数并要求用户每次需要时都加上它，不过在这里我们将使用环境变量。这允许用户设置环境变量一次之后在整个终端会话中所有的搜索都将是大小写不敏感的。
编写一个大小写不敏感 search 函数的失败测试
我们希望增加一个新函数 search_case_insensitive，并将会在设置了环境变量时调用它。这里将继续遵循 TDD 过程，其第一步是再次编写一个失败测试。我们将为新的大小写不敏感搜索函数新增一个测试函数，并将老的测试函数从 one_result 改名为 case_sensitive 来更清楚的表明这两个测试的区别，如示例 12-20 所示：
文件名: src/lib.rs
1. use std::error::Error;
2. use std::fs;
4. pub struct Config {
5. pub query: String,
6. pub filename: String,
7. }
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. }
15. let query = args[1].clone();
16. let filename = args[2].clone();
18. Ok(Config { query, filename })
19. }
20. }
22. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
23. let contents = fs::read_to_string(config.filename)?;
25. for line in search(&config.query, &contents) {
26. println!("{}", line);
27. }
29. Ok(())
30. }
32. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
33. let mut results = Vec::new();
35. for line in contents.lines() {
36. if line.contains(query) {
37. results.push(line);
38. }
39. }
41. results
42. }
44. #[cfg(test)]
45. mod tests {
46. use super::*;
48. #[test]
49. fn case_sensitive() {
50. let query = "duct";
51. let contents = "\
52. Rust:
53. safe, fast, productive.
54. Pick three.
55. Duct tape.";
57. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
58. }
60. #[test]
61. fn case_insensitive() {
62. let query = "rUsT";
63. let contents = "\
64. Rust:
65. safe, fast, productive.
66. Pick three.
67. Trust me.";
69. assert_eq!(
70. vec!["Rust:", "Trust me."],
71. search_case_insensitive(query, contents)
72. );
73. }
74. }
示例 12-20：为准备添加的大小写不敏感函数新增失败测试
注意我们也改变了老测试中 contents 的值。还新增了一个含有文本 "Duct tape." 的行，它有一个大写的 D，这在大小写敏感搜索时不应该匹配 "duct"。我们修改这个测试以确保不会意外破坏已经实现的大小写敏感搜索功能；这个测试现在应该能通过并在处理大小写不敏感搜索时应该能一直通过。
大小写 不敏感 搜索的新测试使用 "rUsT" 作为其查询字符串。在我们将要增加的 search_case_insensitive 函数中，"rUsT" 查询应该包含带有一个大写 R 的 "Rust:" 还有 "Trust me." 这两行，即便他们与查询的大小写都不同。这个测试现在不能编译，因为还没有定义 search_case_insensitive 函数。请随意增加一个总是返回空 vector 的骨架实现，正如示例 12-16 中 search 函数为了使测试通过编译并失败时所做的那样。
实现 search_case_insensitive 函数
search_case_insensitive 函数，如示例 12-21 所示，将与 search 函数基本相同。唯一的区别是它会将 query 变量和每一 line 都变为小写，这样不管输入参数是大写还是小写，在检查该行是否包含查询字符串时都会是小写。
文件名: src/lib.rs
1. use std::error::Error;
2. use std::fs;
4. pub struct Config {
5. pub query: String,
6. pub filename: String,
7. }
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. }
15. let query = args[1].clone();
16. let filename = args[2].clone();
18. Ok(Config { query, filename })
19. }
20. }
22. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
23. let contents = fs::read_to_string(config.filename)?;
25. for line in search(&config.query, &contents) {
26. println!("{}", line);
27. }
29. Ok(())
30. }
32. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
33. let mut results = Vec::new();
35. for line in contents.lines() {
36. if line.contains(query) {
37. results.push(line);
38. }
39. }
41. results
42. }
44. pub fn search_case_insensitive<'a>(
45. query: &str,
46. contents: &'a str,
47. ) -> Vec<&'a str> {
48. let query = query.to_lowercase();
49. let mut results = Vec::new();
51. for line in contents.lines() {
52. if line.to_lowercase().contains(&query) {
53. results.push(line);
54. }
55. }
57. results
58. }
60. #[cfg(test)]
61. mod tests {
62. use super::*;
64. #[test]
65. fn case_sensitive() {
66. let query = "duct";
67. let contents = "\
68. Rust:
69. safe, fast, productive.
70. Pick three.
71. Duct tape.";
73. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
74. }
76. #[test]
77. fn case_insensitive() {
78. let query = "rUsT";
79. let contents = "\
80. Rust:
81. safe, fast, productive.
82. Pick three.
83. Trust me.";
85. assert_eq!(
86. vec!["Rust:", "Trust me."],
87. search_case_insensitive(query, contents)
88. );
89. }
90. }
示例 12-21：定义 search_case_insensitive 函数，它在比较查询和每一行之前将他们都转换为小写
首先我们将 query 字符串转换为小写，并将其覆盖到同名的变量中。对查询字符串调用 to_lowercase 是必需的，这样不管用户的查询是 "rust"、"RUST"、"Rust" 或者 "rUsT"，我们都将其当作 "rust" 处理并对大小写不敏感。虽然 to_lowercase 可以处理基本的 Unicode，但它不是 100% 准确。如果编写真实的程序的话，我们还需多做一些工作，不过这一部分是关于环境变量而不是 Unicode 的，所以这样就够了。
注意 query 现在是一个 String 而不是字符串 slice，因为调用 to_lowercase 是在创建新数据，而不是引用现有数据。如果查询字符串是 "rUsT"，这个字符串 slice 并不包含可供我们使用的小写的 u 或 t，所以必需分配一个包含 "rust" 的新 String。现在当我们将 query 作为一个参数传递给 contains 方法时，需要增加一个 & 因为 contains 的签名被定义为获取一个字符串 slice。
接下来在检查每个 line 是否包含 search 之前增加了一个 to_lowercase 调用将他们都变为小写。现在我们将 line 和 query 都转换成了小写，这样就可以不管查询的大小写进行匹配了。
让我们看看这个实现能否通过测试：
1. $ cargo test
2. Compiling minigrep v0.1.0 (file:///projects/minigrep)
3. Finished test [unoptimized + debuginfo] target(s) in 1.33s
4. Running unittests (target/debug/deps/minigrep-9cd200e5fac0fc94)
6. running 2 tests
7. test tests::case_insensitive ... ok
8. test tests::case_sensitive ... ok
10. test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
12. Running unittests (target/debug/deps/minigrep-9cd200e5fac0fc94)
14. running 0 tests
16. test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
18. Doc-tests minigrep
20. running 0 tests
22. test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
好的！现在，让我们在 run 函数中实际调用新 search_case_insensitive 函数。首先，我们将在 Config 结构体中增加一个配置项来切换大小写敏感和大小写不敏感搜索。增加这些字段会导致编译错误，因为我们还没有在任何地方初始化这些字段：
文件名: src/lib.rs
1. use std::error::Error;
2. use std::fs;
4. pub struct Config {
5. pub query: String,
6. pub filename: String,
7. pub case_sensitive: bool,
8. }
10. impl Config {
11. pub fn new(args: &[String]) -> Result<Config, &'static str> {
12. if args.len() < 3 {
13. return Err("not enough arguments");
14. }
16. let query = args[1].clone();
17. let filename = args[2].clone();
19. Ok(Config { query, filename })
20. }
21. }
23. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
24. 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. };
32. for line in results {
33. println!("{}", line);
34. }
36. Ok(())
37. }
39. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
40. let mut results = Vec::new();
42. for line in contents.lines() {
43. if line.contains(query) {
44. results.push(line);
45. }
46. }
48. results
49. }
51. pub fn search_case_insensitive<'a>(
52. query: &str,
53. contents: &'a str,
54. ) -> Vec<&'a str> {
55. let query = query.to_lowercase();
56. let mut results = Vec::new();
58. for line in contents.lines() {
59. if line.to_lowercase().contains(&query) {
60. results.push(line);
61. }
62. }
64. results
65. }
67. #[cfg(test)]
68. mod tests {
69. use super::*;
71. #[test]
72. fn case_sensitive() {
73. let query = "duct";
74. let contents = "\
75. Rust:
76. safe, fast, productive.
77. Pick three.
78. Duct tape.";
80. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
81. }
83. #[test]
84. fn case_insensitive() {
85. let query = "rUsT";
86. let contents = "\
87. Rust:
88. safe, fast, productive.
89. Pick three.
90. Trust me.";
92. assert_eq!(
93. vec!["Rust:", "Trust me."],
94. search_case_insensitive(query, contents)
95. );
96. }
97. }
这里增加了 case_sensitive 字符来存放一个布尔值。接着我们需要 run 函数检查 case_sensitive 字段的值并使用它来决定是否调用 search 函数或 search_case_insensitive 函数，如示例 12-22 所示。注意这还不能编译：
文件名: src/lib.rs
1. use std::error::Error;
2. use std::fs;
4. pub struct Config {
5. pub query: String,
6. pub filename: String,
7. pub case_sensitive: bool,
8. }
10. impl Config {
11. pub fn new(args: &[String]) -> Result<Config, &'static str> {
12. if args.len() < 3 {
13. return Err("not enough arguments");
14. }
16. let query = args[1].clone();
17. let filename = args[2].clone();
19. Ok(Config { query, filename })
20. }
21. }
23. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
24. 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. };
32. for line in results {
33. println!("{}", line);
34. }
36. Ok(())
37. }
39. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
40. let mut results = Vec::new();
42. for line in contents.lines() {
43. if line.contains(query) {
44. results.push(line);
45. }
46. }
48. results
49. }
51. pub fn search_case_insensitive<'a>(
52. query: &str,
53. contents: &'a str,
54. ) -> Vec<&'a str> {
55. let query = query.to_lowercase();
56. let mut results = Vec::new();
58. for line in contents.lines() {
59. if line.to_lowercase().contains(&query) {
60. results.push(line);
61. }
62. }
64. results
65. }
67. #[cfg(test)]
68. mod tests {
69. use super::*;
71. #[test]
72. fn case_sensitive() {
73. let query = "duct";
74. let contents = "\
75. Rust:
76. safe, fast, productive.
77. Pick three.
78. Duct tape.";
80. assert_eq!(vec!["safe, fast, productive."], search(query, contents));
81. }
83. #[test]
84. fn case_insensitive() {
85. let query = "rUsT";
86. let contents = "\
87. Rust:
88. safe, fast, productive.
89. Pick three.
90. Trust me.";
92. assert_eq!(
93. vec!["Rust:", "Trust me."],
94. search_case_insensitive(query, contents)
95. );
96. }
97. }
示例 12-22：根据 config.case_sensitive 的值调用 search 或 search_case_insensitive
最后需要实际检查环境变量。处理环境变量的函数位于标准库的 env 模块中，所以我们需要在 src/lib.rs 的开头增加一个 use std::env; 行将这个模块引入作用域中。接着在 Config::new 中使用 env 模块的 var 方法来检查一个叫做 CASE_INSENSITIVE 的环境变量，如示例 12-23 所示：
文件名: src/lib.rs
1. use std::env;
2. // --snip--
4. use std::error::Error;
5. use std::fs;
7. pub struct Config {
8. pub query: String,
9. pub filename: String,
10. pub case_sensitive: bool,
11. }
13. impl Config {
14. pub fn new(args: &[String]) -> Result<Config, &'static str> {
15. if args.len() < 3 {
16. return Err("not enough arguments");
17. }
19. let query = args[1].clone();
20. let filename = args[2].clone();
22. let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
24. Ok(Config {
25. query,
26. filename,
27. case_sensitive,
28. })
29. }
30. }
32. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
33. let contents = fs::read_to_string(config.filename)?;
35. let results = if config.case_sensitive {
36. search(&config.query, &contents)
37. } else {
38. search_case_insensitive(&config.query, &contents)
39. };
41. for line in results {
42. println!("{}", line);
43. }
45. Ok(())
46. }
48. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
49. let mut results = Vec::new();
51. for line in contents.lines() {
52. if line.contains(query) {
53. results.push(line);
54. }
55. }
57. results
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. }
示例 12-23：检查叫做 CASE_INSENSITIVE 的环境变量
这里创建了一个新变量 case_sensitive。为了设置它的值，需要调用 env::var 函数并传递我们需要寻找的环境变量名称，CASE_INSENSITIVE。env::var 返回一个 Result，它在环境变量被设置时返回包含其值的 Ok 成员，并在环境变量未被设置时返回 Err 成员。
我们使用 Result 的 is_err 方法来检查其是否是一个 error（也就是环境变量未被设置的情况），这也就意味着我们 需要 进行一个大小写敏感搜索。如果CASE_INSENSITIVE 环境变量被设置为任何值，is_err 会返回 false 并将进行大小写不敏感搜索。我们并不关心环境变量所设置的 值，只关心它是否被设置了，所以检查 is_err 而不是 unwrap、expect 或任何我们已经见过的 Result 的方法。
我们将变量 case_sensitive 的值传递给 Config 实例，这样 run 函数可以读取其值并决定是否调用 search 或者示例 12-22 中实现的 search_case_insensitive。
让我们试一试吧！首先不设置环境变量并使用查询 to 运行程序，这应该会匹配任何全小写的单词 “to” 的行：
1. $ cargo run to poem.txt
2. Compiling minigrep v0.1.0 (file:///projects/minigrep)
3. Finished dev [unoptimized + debuginfo] target(s) in 0.0s
4. Running `target/debug/minigrep to poem.txt`
5. Are you nobody, too?
6. How dreary to be somebody!
看起来程序仍然能够工作！现在将 CASE_INSENSITIVE 设置为 1 并仍使用相同的查询 to。
如果你使用 PowerShell，则需要用两个命令来分别设置环境变量并运行程序：
1. PS> $Env:CASE_INSENSITIVE=1; cargo run to poem.txt
这回应该得到包含可能有大写字母的 “to” 的行：
1. $ (CASE_INSENSITIVE=1; cargo run to poem.txt)
2. Finished dev [unoptimized + debuginfo] target(s) in 0.0s
3. Running `target/debug/minigrep to poem.txt`
4. Are you nobody, too?
5. How dreary to be somebody!
6. To tell your name the livelong day
7. To an admiring bog!
好极了，我们也得到了包含 “To” 的行！现在 minigrep 程序可以通过环境变量控制进行大小写不敏感搜索了。现在你知道了如何管理由命令行参数或环境变量设置的选项了！
一些程序允许对相同配置同时使用参数 和 环境变量。在这种情况下，程序来决定参数和环境变量的优先级。作为一个留给你的测试，尝试通过一个命令行参数或一个环境变量来控制大小写不敏感搜索。并在运行程序时遇到矛盾值时决定命令行参数和环境变量的优先级。
std::env 模块还包含了更多处理环境变量的实用功能；请查看官方文档来了解其可用的功能。
