การใช้งานตัวแปรสภาพแวดล้อม
เราจะพัฒนาโปรแกรม minigrep เพิ่มเติมด้วยการเพิ่มฟีเจอร์ใหม่: ตัวเลือกสำหรับการค้นหาแบบไม่สนใจตัวพิมพ์เล็ก-ใหญ่ (case-insensitive) ที่ผู้ใช้งานสามารถเปิดใช้งานผ่านตัวแปรสภาพแวดล้อม (environment variable) ได้ เราอาจเลือกสร้างฟีเจอร์นี้เป็นออปชันของคำสั่งบรรทัดคำสั่ง และกำหนดให้ผู้ใช้ต้องระบุทุกครั้งที่ต้องการใช้งานก็ได้ แต่การเลือกใช้ตัวแปรสภาพแวดล้อมจะช่วยให้ผู้ใช้ตั้งค่าเพียงครั้งเดียว แล้วการค้นหาหลังจากนั้นทั้งหมดในเซสชันของเทอร์มินัลนั้นจะทำงานแบบไม่สนใจตัวพิมพ์เล็ก-ใหญ่โดยอัตโนมัติ
การเขียนเทสต์ที่ล้มเหลวสำหรับการค้นหาแบบไม่คำนึงถึงตัวพิมพ์เล็ก-ใหญ่
ก่อนอื่น เราจะเพิ่มฟังก์ชันใหม่ชื่อ search_case_insensitive ซึ่งจะถูกเรียกใช้งานเมื่อมีการตั้งค่าตัวแปรสภาพแวดล้อมขึ้นมา เราจะยังคงปฏิบัติตามแนวทาง TDD ต่อไป ดังนั้นขั้นตอนแรกจึงเป็นการเขียนเทสต์ที่ล้มเหลวอีกครั้ง โดยเราจะเพิ่มเทสต์ใหม่สำหรับฟังก์ชัน search_case_insensitive และเปลี่ยนชื่อเทสต์เดิมของเราจาก one_result เป็น case_sensitive เพื่อแยกแยะความแตกต่างระหว่างเทสต์ทั้งสองให้ชัดเจนยิ่งขึ้น ดังแสดงในลิสติ้ง 12-20
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[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)
);
}
}
โปรดสังเกตว่าเราได้ปรับแก้ค่า contents ในเทสต์เดิมด้วย โดยเพิ่มบรรทัดใหม่ที่มีข้อความ "Duct tape." ซึ่งขึ้นต้นด้วยตัวอักษร D ตัวพิมพ์ใหญ่ ซึ่งต้องไม่ตรงกับคำค้น "duct" เมื่อเราค้นหาแบบคำนึงถึงตัวพิมพ์เล็ก-ใหญ่ การแก้ไขเทสต์เดิมในลักษณะนี้จะช่วยให้มั่นใจได้ว่าเราจะไม่เผลอทำให้ระบบค้นหาแบบคำนึงถึงตัวพิมพ์เล็ก-ใหญ่ที่เราพัฒนาไว้แล้วเสียหาย เทสต์นี้ควรผ่านตั้งแต่ตอนนี้ และควรจะยังคงผ่านต่อไปในระหว่างที่เรากำลังพัฒนาฟังก์ชันการค้นหาแบบไม่คำนึงถึงตัวพิมพ์เล็ก-ใหญ่
ส่วนเทสต์ใหม่สำหรับการค้นหาแบบ_ไม่คำนึงถึง_ตัวพิมพ์เล็ก-ใหญ่จะใช้คำค้นเป็น "rUsT" ในฟังก์ชัน search_case_insensitive ที่เรากำลังจะสร้างขึ้น คำค้น "rUsT" นี้จะต้องจับคู่ตรงกับทั้งบรรทัดที่มีข้อความ "Rust:" (ซึ่งขึ้นต้นด้วยตัวพิมพ์ใหญ่ R) และบรรทัด "Trust me." ได้ แม้ว่าทั้งสองบรรทัดจะมีตัวพิมพ์ที่ต่างไปจากคำค้นก็ตาม นี่คือเทสต์ที่ล้มเหลวของเรา และในตอนนี้มันจะยังคอมไพล์ไม่ผ่านเนื่องจากเรายังไม่ได้นิยามฟังก์ชัน search_case_insensitive ขึ้นมา คุณสามารถเขียนโครงร่างฟังก์ชัน (skeleton implementation) ที่คืนค่าเป็นเวกเตอร์ว่างไปก่อนได้ คล้ายกับที่เราเคยทำกับฟังก์ชัน search ในลิสติ้ง 12-16 เพื่อตรวจสอบว่าเทสต์สามารถคอมไพล์ได้และล้มเหลวตามที่คาดไว้
การอิมพลีเมนต์ฟังก์ชัน search_case_insensitive
ฟังก์ชัน search_case_insensitive ดังแสดงในลิสติ้ง 12-21 จะมีโครงสร้างเกือบเหมือนกับฟังก์ชัน search เดิมทุกประการ ความแตกต่างเพียงอย่างเดียวคือเราจะแปลงทั้งคำค้น query และแต่ละบรรทัด line ให้เป็นตัวพิมพ์เล็ก เพื่อให้ไม่ว่าอาร์กิวเมนต์ที่ส่งเข้ามาจะมีตัวพิมพ์แบบใด ทั้งสองส่วนก็จะมีตัวพิมพ์เหมือนกันเมื่อเราตรวจสอบว่าบรรทัดนั้นมีคำค้นอยู่หรือไม่
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
pub fn search_case_insensitive<'a>(
query: &str,
contents: &'a str,
) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
#[cfg(test)]
mod tests {
use super::*;
#[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)
);
}
}
ก่อนอื่น เราแปลงสตริง query ให้เป็นตัวพิมพ์เล็กทั้งหมด แล้วเก็บไว้ในตัวแปรใหม่ที่มีชื่อเดียวกัน ซึ่งเป็นการบดบังตัวแปร (shadowing) query ตัวเดิม การเรียกใช้ to_lowercase บนตัวแปรคำค้นเป็นสิ่งจำเป็น เพื่อให้ไม่ว่าผู้ใช้จะป้อนคำค้นเข้ามาเป็น "rust", "RUST", "Rust" หรือ "rUsT" เราก็จะปฏิบัติต่อคำค้นนั้นเสมือนเป็น "rust" เสมอโดยไม่สนใจตัวพิมพ์ แม้ว่า to_lowercase จะจัดการกับอักขระ Unicode พื้นฐานได้ แต่อาจไม่ได้แม่นยำร้อยเปอร์เซ็นต์ หากเรากำลังพัฒนาแอปพลิเคชันใช้งานจริง เราอาจต้องจัดการรายละเอียดเพิ่มเติมตรงจุดนี้ ทว่าในหัวข้อนี้เราเน้นเรื่องตัวแปรสภาพแวดล้อม ไม่ใช่เรื่อง Unicode จึงขอละไว้ในฐานที่เข้าใจ
โปรดสังเกตว่าตอนนี้ query มีชนิดเป็น String ไม่ใช่สตริงสไลซ์ (&str) อีกต่อไป เนื่องจากเมธอด to_lowercase จะสร้างข้อมูลใหม่ขึ้นมาแทนที่จะอ้างอิงข้อมูลเดิม ตัวอย่างเช่น หากคำค้นคือ "rUsT": สตริงสไลซ์เดิมนั้นไม่มีตัวอักษร u หรือ t ตัวพิมพ์เล็กให้เราใช้อ้างอิง เราจึงจำเป็นต้องจัดสรร String ก้อนใหม่ที่เก็บข้อความ "rust" ดังนั้นเมื่อเราส่ง query เป็นอาร์กิวเมนต์ให้กับเมธอด contains เราจึงต้องใส่เครื่องหมายแอมเพอร์แซนด์ (&) เนื่องจากซิกเนเจอร์ของเมธอด contains กำหนดไว้ว่าต้องรับสตริงสไลซ์
จากนั้น เราจึงเรียกใช้ to_lowercase บนแต่ละบรรทัด line เพื่อแปลงตัวอักขระทั้งหมดให้เป็นตัวพิมพ์เล็กเช่นกัน เมื่อเราแปลงทั้ง line และ query ให้เป็นตัวพิมพ์เล็กเหมือนกันแล้ว เราก็จะสามารถตรวจหาคำที่ตรงกันได้เสมอ ไม่ว่าคำค้นเดิมจะมีตัวพิมพ์แบบใดก็ตาม
มาดูกันว่าการอิมพลีเมนต์นี้ผ่านเทสต์หรือไม่:
$ cargo test
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished `test` profile [unoptimized + debuginfo] target(s) in 1.33s
Running unittests src/lib.rs (target/debug/deps/minigrep-9cd200e5fac0fc94)
running 2 tests
test tests::case_insensitive ... ok
test tests::case_sensitive ... ok
test result: ok. 2 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 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Doc-tests minigrep
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
ยอดเยี่ยมมาก! เทสต์ผ่านเรียบร้อยแล้ว ตอนนี้มาเรียกใช้ฟังก์ชัน search_case_insensitive ใหม่นี้จากฟังก์ชัน run กันครับ ก่อนอื่น เราจะเพิ่มตัวเลือกการกำหนดค่าลงใน struct Config เพื่อสลับการทำงานระหว่างการค้นหาแบบคำนึงถึงตัวพิมพ์เล็ก-ใหญ่กับการค้นหาแบบไม่คำนึงถึงตัวพิมพ์ การเพิ่มฟิลด์นี้จะทำให้คอมไพเลอร์แจ้งข้อผิดพลาด เนื่องจากเรายังไม่ได้กำหนดค่าเริ่มต้นให้กับฟิลด์นี้ในจุดอื่นๆ:
ชื่อไฟล์: src/main.rs
use std::env;
use std::error::Error;
use std::fs;
use std::process;
use minigrep::{search, search_case_insensitive};
// --snip--
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::build(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {err}");
process::exit(1);
});
if let Err(e) = run(config) {
println!("Application error: {e}");
process::exit(1);
}
}
pub struct Config {
pub query: String,
pub file_path: String,
pub ignore_case: bool,
}
impl Config {
fn build(args: &[String]) -> Result<Config, &'static str> {
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 })
}
}
fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.file_path)?;
let results = if config.ignore_case {
search_case_insensitive(&config.query, &contents)
} else {
search(&config.query, &contents)
};
for line in results {
println!("{line}");
}
Ok(())
}
เราได้เพิ่มฟิลด์ ignore_case ซึ่งเก็บค่าบูลีน จากนั้น เราต้องแก้ไขฟังก์ชัน run ให้ตรวจสอบค่าของฟิลด์ ignore_case นี้ เพื่อใช้ตัดสินใจว่าจะเรียกใช้ฟังก์ชัน search หรือ search_case_insensitive ดังแสดงในลิสติ้ง 12-22 (ซึ่งโค้ดนี้จะยังคอมไพล์ไม่ผ่านในตอนนี้)
use std::env;
use std::error::Error;
use std::fs;
use std::process;
use minigrep::{search, search_case_insensitive};
// --snip--
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::build(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {err}");
process::exit(1);
});
if let Err(e) = run(config) {
println!("Application error: {e}");
process::exit(1);
}
}
pub struct Config {
pub query: String,
pub file_path: String,
pub ignore_case: bool,
}
impl Config {
fn build(args: &[String]) -> Result<Config, &'static str> {
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 })
}
}
fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.file_path)?;
let results = if config.ignore_case {
search_case_insensitive(&config.query, &contents)
} else {
search(&config.query, &contents)
};
for line in results {
println!("{line}");
}
Ok(())
}
สุดท้าย เราต้องตรวจสอบตัวแปรสภาพแวดล้อม ฟังก์ชันสำหรับการทำงานกับตัวแปรสภาพแวดล้อมจะอยู่ในมอดูล env ของไลบรารีมาตรฐาน ซึ่งเราได้นำเข้ามาไว้ในสโคปที่ด้านบนของ src/main.rs เรียบร้อยแล้ว เราจะใช้ฟังก์ชัน var จากมอดูล env เพื่อตรวจสอบว่ามีการกำหนดค่าให้กับตัวแปรสภาพแวดล้อมที่ชื่อ IGNORE_CASE ไว้หรือไม่ ดังแสดงในลิสติ้ง 12-23
use std::env;
use std::error::Error;
use std::fs;
use std::process;
use minigrep::{search, search_case_insensitive};
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::build(&args).unwrap_or_else(|err| {
println!("Problem parsing arguments: {err}");
process::exit(1);
});
if let Err(e) = run(config) {
println!("Application error: {e}");
process::exit(1);
}
}
pub struct Config {
pub query: String,
pub file_path: String,
pub ignore_case: bool,
}
impl Config {
fn build(args: &[String]) -> Result<Config, &'static str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let file_path = args[2].clone();
let ignore_case = env::var("IGNORE_CASE").is_ok();
Ok(Config {
query,
file_path,
ignore_case,
})
}
}
fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = fs::read_to_string(config.file_path)?;
let results = if config.ignore_case {
search_case_insensitive(&config.query, &contents)
} else {
search(&config.query, &contents)
};
for line in results {
println!("{line}");
}
Ok(())
}
ในที่นี้ เราสร้างตัวแปรใหม่ชื่อ ignore_case โดยกำหนดค่าจากการเรียกใช้ฟังก์ชัน env::var พร้อมส่งชื่อตัวแปรสภาพแวดล้อม IGNORE_CASE เข้าไป ฟังก์ชัน env::var จะส่งคืนค่าเป็น Result ซึ่งจะเป็นวาเรียนต์ Ok ที่เก็บค่าของตัวแปรสภาพแวดล้อมไว้หากตัวแปรสภาพแวดล้อมนั้นได้รับการกำหนดค่าใดๆ เอาไว้ และจะส่งคืนวาเรียนต์ Err หากไม่มีการตั้งค่าตัวแปรสภาพแวดล้อมดังกล่าว
เราใช้เมธอด is_ok บน Result เพื่อตรวจสอบว่าตัวแปรสภาพแวดล้อมนั้นถูกตั้งค่าไว้หรือไม่ ซึ่งหากมีการตั้งค่าไว้ ก็แสดงว่าโปรแกรมควรค้นหาแบบไม่คำนึงถึงตัวพิมพ์เล็ก-ใหญ่ แต่หากตัวแปรสภาพแวดล้อม IGNORE_CASE ไม่ได้ถูกตั้งค่าไว้ เมธอด is_ok จะส่งคืนค่า false และโปรแกรมจะค้นหาแบบคำนึงถึงตัวพิมพ์ตามปกติ ในที่นี้เราไม่ได้สนใจว่า_ค่า_ของตัวแปรสภาพแวดล้อมจะเป็นอะไร สนใจเพียงแค่ว่ามันถูกตั้งค่าไว้หรือไม่เท่านั้น เราจึงตรวจสอบด้วย is_ok แทนที่จะใช้ unwrap, expect หรือเมธอดอื่นๆ บน Result
เราส่งค่าในตัวแปร ignore_case ไปยังอินสแตนซ์ของ Config เพื่อให้ฟังก์ชัน run อ่านค่านั้นไปใช้ตัดสินใจว่าจะเรียก search_case_insensitive หรือ search ตามที่เราได้พัฒนาไว้ในลิสติ้ง 12-22
มาลองทดสอบกันดูครับ! ก่อนอื่น เราจะรันโปรแกรมโดยยังไม่ตั้งค่าตัวแปรสภาพแวดล้อม และค้นหาด้วยคำว่า to ซึ่งควรตรงกับบรรทัดที่มีคำว่า to เป็นตัวพิมพ์เล็กทั้งหมดเท่านั้น:
$ cargo run -- to poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep to poem.txt`
Are you nobody, too?
How dreary to be somebody!
ดูเหมือนว่าการทำงานยังถูกต้องดี! ตอนนี้ลองรันโปรแกรมโดยกำหนดค่า IGNORE_CASE ให้เป็น 1 แต่ยังคงค้นหาด้วยคำว่า to เช่นเดิม:
$ IGNORE_CASE=1 cargo run -- to poem.txt
หากคุณใช้ PowerShell คุณจะต้องตั้งค่าตัวแปรสภาพแวดล้อมและรันโปรแกรมเป็นคำสั่งแยกกัน:
PS> $Env:IGNORE_CASE=1; cargo run -- to poem.txt
การทำเช่นนี้จะทำให้ค่า IGNORE_CASE คงอยู่ตลอดช่วงที่เหลือของเซสชันเชลล์ของคุณ คุณสามารถยกเลิกการตั้งค่าได้ด้วย cmdlet Remove-Item:
PS> Remove-Item Env:IGNORE_CASE
เราควรได้บรรทัดที่มีคำว่า to ซึ่งอาจมีตัวอักษรพิมพ์ใหญ่ปนอยู่ด้วย:
Are you nobody, too?
How dreary to be somebody!
To tell your name the livelong day
To an admiring bog!
ยอดเยี่ยมมาก! เราได้บรรทัดที่มีคำว่า To ติดมาด้วยแล้ว! ตอนนี้โปรแกรม minigrep ของเราสามารถค้นหาแบบไม่คำนึงถึงตัวพิมพ์เล็ก-ใหญ่โดยควบคุมผ่านตัวแปรสภาพแวดล้อมได้เรียบร้อยแล้ว ถึงตรงนี้คุณก็ได้เรียนรู้วิธีจัดการตัวเลือกการทำงานของโปรแกรม ทั้งผ่านทางอาร์กิวเมนต์ของบรรทัดคำสั่งและผ่านตัวแปรสภาพแวดล้อม
บางโปรแกรมอาจเปิดให้ระบุการกำหนดค่าแบบเดียวกันผ่านทั้งอาร์กิวเมนต์_และ_ตัวแปรสภาพแวดล้อม ในกรณีเช่นนั้น ตัวโปรแกรมจะเป็นผู้ตัดสินว่าตัวเลือกใดควรมีลำดับความสำคัญสูงกว่ากัน เพื่อเป็นแบบฝึกหัดทบทวนด้วยตนเอง ลองปรับให้โปรแกรมควบคุมการค้นหาแบบไม่สนใจตัวพิมพ์เล็ก-ใหญ่ได้ทั้งผ่านอาร์กิวเมนต์บรรทัดคำสั่งหรือตัวแปรสภาพแวดล้อมดูครับ และลองตัดสินใจว่าระหว่างอาร์กิวเมนต์กับตัวแปรสภาพแวดล้อม อย่างใดควรมีลำดับความสำคัญสูงกว่า หากผู้ใช้สั่งรันโดยตั้งค่าให้ตัวหนึ่งค้นหาแบบคำนึงถึงตัวพิมพ์ แต่อีกตัวหนึ่งสั่งให้ไม่คำนึงถึงตัวพิมพ์
มอดูล std::env ยังมีฟังก์ชันที่มีประโยชน์อีกมากมายสำหรับการจัดการตัวแปรสภาพแวดล้อม ลองศึกษาเอกสารประกอบเพื่อดูว่ามีฟังก์ชันอะไรให้เรียกใช้งานได้บ้าง