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

Bekerja dengan Environment Variable

Kita akan menyempurnakan biner minigrep dengan menambahkan fitur ekstra: opsi pencarian yang tidak membedakan huruf besar-kecil yang bisa dinyalakan pengguna lewat sebuah environment variable. Kita bisa saja menjadikan fitur ini sebagai opsi command line dan mewajibkan pengguna mengetikkannya setiap kali ingin menggunakannya, tetapi dengan menjadikannya sebuah environment variable, pengguna cukup mengaturnya sekali lalu semua pencarian mereka dalam sesi terminal itu menjadi tidak membedakan huruf besar-kecil.

Pertama, kita tambahkan fungsi baru search_case_insensitive ke library minigrep yang akan dipanggil ketika environment variable memiliki nilai. Kita terus mengikuti proses TDD, jadi langkah pertama kembali adalah menulis test yang gagal. Kita akan menambahkan test baru untuk fungsi search_case_insensitive dan mengganti nama test lama kita dari one_result menjadi case_sensitive agar perbedaan antara kedua test menjadi jelas, seperti yang ditunjukkan pada Listing 12-20.

Filename: src/lib.rs
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)
        );
    }
}
Listing 12-20: Menambahkan test gagal baru untuk fungsi yang tidak membedakan huruf besar-kecil yang akan kita tambahkan

Perhatikan bahwa kita juga mengedit contents pada test lama. Kita menambahkan baris baru dengan teks "Duct tape." yang memakai huruf D kapital yang seharusnya tidak cocok dengan query "duct" ketika kita mencari dengan cara yang membedakan huruf besar-kecil. Mengubah test lama dengan cara ini membantu memastikan kita tidak tanpa sengaja merusak fungsi pencarian yang membedakan huruf besar-kecil yang sudah kita terapkan. Test ini seharusnya lulus sekarang dan harus terus lulus saat kita mengerjakan pencarian yang tidak membedakan huruf besar-kecil.

Test baru untuk pencarian yang tidak membedakan huruf besar-kecil memakai "rUsT" sebagai query. Pada fungsi search_case_insensitive yang akan kita tambahkan, query "rUsT" harus cocok dengan baris yang berisi "Rust:" dengan R kapital dan cocok dengan baris "Trust me." meskipun keduanya memiliki huruf yang berbeda dari query. Ini adalah test kita yang gagal, dan ia akan gagal dikompilasi karena kita belum mendefinisikan fungsi search_case_insensitive. Silakan tambahkan implementasi kerangka yang selalu mengembalikan vector kosong, mirip dengan yang kita lakukan untuk fungsi search pada Listing 12-16, untuk melihat test tersebut terkompilasi dan gagal.

Mengimplementasikan Fungsi search_case_insensitive

Fungsi search_case_insensitive, yang ditunjukkan pada Listing 12-21, hampir sama dengan fungsi search. Satu-satunya perbedaan adalah kita akan mengubah query dan setiap line menjadi huruf kecil, sehingga apa pun huruf pada argumen masukan, keduanya akan memiliki huruf yang sama ketika kita memeriksa apakah baris tersebut memuat query.

Filename: src/lib.rs
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)
        );
    }
}
Listing 12-21: Mendefinisikan fungsi search_case_insensitive untuk mengubah query dan baris menjadi huruf kecil sebelum membandingkannya

Pertama, kita mengubah string query menjadi huruf kecil dan menyimpannya dalam variabel baru dengan nama yang sama, sehingga menimpa query yang semula. Memanggil to_lowercase pada query itu perlu agar, apa pun query pengguna—"rust", "RUST", "Rust", atau "rUsT"—kita memperlakukannya seolah-olah "rust" dan tidak mempedulikan hurufnya. Meskipun to_lowercase menangani Unicode dasar, hasilnya tidak 100 persen akurat. Jika kita menulis aplikasi sungguhan, kita pasti ingin melakukan sedikit lebih banyak di sini, tetapi bagian ini membahas environment variable, bukan Unicode, jadi kita biarkan saja di sini.

Perhatikan bahwa query sekarang adalah String, bukan string slice, karena memanggil to_lowercase menciptakan data baru alih-alih mereferensikan data yang sudah ada. Misalkan query-nya "rUsT": string slice itu tidak memuat u atau t huruf kecil yang bisa kita pakai, jadi kita harus mengalokasikan String baru yang berisi "rust". Ketika kita sekarang meneruskan query sebagai argumen ke method contains, kita perlu menambahkan ampersand karena signature contains didefinisikan untuk menerima string slice.

Berikutnya, kita menambahkan panggilan to_lowercase pada setiap line untuk mengubah semua karakter menjadi huruf kecil. Sekarang setelah line dan query diubah ke huruf kecil, kita akan menemukan kecocokan apa pun huruf pada query.

Mari kita lihat apakah implementasi ini lolos pada test-test:

$ 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

Hebat! Semua lolos. Sekarang mari kita panggil fungsi baru search_case_insensitive dari fungsi run. Pertama, kita akan menambahkan opsi konfigurasi ke struct Config untuk beralih antara pencarian yang membedakan dan yang tidak membedakan huruf besar-kecil. Menambahkan field ini akan menimbulkan error compiler karena kita belum menginisialisasi field ini di mana pun:

Nama file: 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(())
}

Kita menambahkan field ignore_case yang menyimpan nilai Boolean. Berikutnya, kita perlu membuat fungsi run memeriksa nilai field ignore_case dan memakainya untuk memutuskan apakah akan memanggil fungsi search atau fungsi search_case_insensitive, seperti yang ditunjukkan pada Listing 12-22. Ini masih belum akan terkompilasi.

Filename: 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(())
}
Listing 12-22: Memanggil search atau search_case_insensitive berdasarkan nilai di config.ignore_case

Akhirnya, kita perlu memeriksa environment variable tersebut. Fungsi-fungsi untuk bekerja dengan environment variable ada di module env dalam standard library, yang sudah berada dalam scope di bagian atas src/main.rs. Kita akan memakai fungsi var dari module env untuk memeriksa apakah ada nilai yang sudah ditetapkan untuk environment variable bernama IGNORE_CASE, seperti yang ditunjukkan pada Listing 12-23.

Filename: src/main.rs
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(())
}
Listing 12-23: Memeriksa nilai apa pun dalam environment variable bernama IGNORE_CASE

Di sini kita membuat variabel baru, ignore_case. Untuk menetapkan nilainya, kita memanggil fungsi env::var dan meneruskan nama environment variable IGNORE_CASE kepadanya. Fungsi env::var mengembalikan Result yang akan menjadi varian Ok yang sukses dan memuat nilai environment variable jika variable tersebut ditetapkan ke suatu nilai. Ia akan mengembalikan varian Err jika environment variable itu tidak ditetapkan.

Kita memakai method is_ok pada Result untuk memeriksa apakah environment variable sudah ditetapkan, yang berarti program harus melakukan pencarian yang tidak membedakan huruf besar-kecil. Jika environment variable IGNORE_CASE tidak ditetapkan ke apa pun, is_ok akan mengembalikan false dan program akan melakukan pencarian yang membedakan huruf besar-kecil. Kita tidak peduli dengan nilai environment variable itu, hanya apakah ia ditetapkan atau tidak, jadi kita memeriksa is_ok alih-alih memakai unwrap, expect, atau method lain yang sudah kita lihat pada Result.

Kita meneruskan nilai dalam variabel ignore_case ke instance Config agar fungsi run bisa membaca nilai itu dan memutuskan apakah akan memanggil search_case_insensitive atau search, seperti yang kita terapkan pada Listing 12-22.

Mari kita coba! Pertama, kita akan menjalankan program tanpa environment variable ditetapkan dan dengan query to, yang seharusnya cocok dengan baris apa pun yang memuat kata to dalam huruf kecil semua:

$ 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!

Tampaknya itu masih berhasil! Sekarang mari kita jalankan program dengan IGNORE_CASE ditetapkan ke 1 tetapi dengan query to yang sama:

$ IGNORE_CASE=1 cargo run -- to poem.txt

Jika kamu memakai PowerShell, kamu perlu menetapkan environment variable dan menjalankan program sebagai perintah-perintah terpisah:

PS> $Env:IGNORE_CASE=1; cargo run -- to poem.txt

Ini akan membuat IGNORE_CASE tetap berlaku selama sisa sesi shell kamu. Nilainya bisa dihapus dengan cmdlet Remove-Item:

PS> Remove-Item Env:IGNORE_CASE

Kita seharusnya mendapat baris-baris yang memuat to yang mungkin memiliki huruf kapital:

Are you nobody, too?
How dreary to be somebody!
To tell your name the livelong day
To an admiring bog!

Luar biasa, kita juga mendapat baris-baris yang memuat To! Program minigrep kita sekarang bisa melakukan pencarian yang tidak membedakan huruf besar-kecil yang dikendalikan oleh environment variable. Sekarang kamu tahu cara mengelola opsi yang ditetapkan baik lewat argumen command line maupun environment variable.

Beberapa program mengizinkan argumen dan environment variable untuk konfigurasi yang sama. Dalam kasus seperti itu, program memutuskan mana yang lebih diutamakan. Untuk latihan mandiri lainnya, coba kendalikan sensitivitas huruf besar-kecil lewat argumen command line atau environment variable. Putuskan apakah argumen command line atau environment variable yang harus diutamakan jika program dijalankan dengan salah satunya ditetapkan untuk membedakan huruf besar-kecil dan yang lain untuk mengabaikannya.

Module std::env memuat banyak fitur berguna lain untuk bekerja dengan environment variable: lihat dokumentasinya untuk mengetahui apa saja yang tersedia.