Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

การใช้งานตัวแปรสภาพแวดล้อม

เราจะพัฒนาโปรแกรม 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 ยังมีฟังก์ชันที่มีประโยชน์อีกมากมายสำหรับการจัดการตัวแปรสภาพแวดล้อม ลองศึกษาเอกสารประกอบเพื่อดูว่ามีฟังก์ชันอะไรให้เรียกใช้งานได้บ้าง