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

ปรับปรุงโปรเจกต์ I/O ของเรา

ด้วยความรู้ใหม่เกี่ยวกับอิเทอเรเตอร์ (iterator) นี้ เราสามารถนำมาปรับปรุงโปรเจกต์ I/O จากบทที่ 12 ให้โค้ดในหลายๆ จุดมีความชัดเจนและกระชับยิ่งขึ้นได้ มาดูกันว่าอิเทอเรเตอร์จะช่วยยกระดับการอิมพลีเมนต์ฟังก์ชัน Config::build และฟังก์ชัน search ของเราได้อย่างไรบ้าง

ขจัด clone ด้วยอิเทอเรเตอร์

ในลิสติ้ง 12-6 เราได้เพิ่มโค้ดที่รับสไลซ์ของค่า String เข้ามา แล้วสร้างอินสแตนซ์ของ struct Config ขึ้นมาโดยการเข้าถึงตำแหน่งดัชนีในสไลซ์และทำการโคลน (clone) ค่าเหล่านั้น เพื่อให้ struct Config ได้รับสิทธิ์ความเป็นเจ้าของในค่านั้น ในลิสติ้ง 13-17 เราได้นำการพัฒนาฟังก์ชัน Config::build จากลิสติ้ง 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(())
}

ในตอนนั้น เราได้บอกไว้ว่าไม่ต้องกังวลเรื่องการเรียกคำสั่ง clone ที่อาจดูไม่มีประสิทธิภาพ เพราะเราจะกลับมาปรับปรุงโค้ดส่วนนี้ในภายหลัง และตอนนี้ก็ถึงเวลาแล้วครับ!

สาเหตุที่เราจำเป็นต้องใช้ clone ในตอนนั้นก็เพราะว่า พารามิเตอร์ args เป็นเพียงสไลซ์ที่เก็บเรเฟอเรนซ์ของ String และตัวฟังก์ชัน build เองก็ไม่ได้เป็นเจ้าของข้อมูลใน args แต่การจะส่งคืนอินสแตนซ์ของ Config ที่สมบูรณ์ออกมาได้นั้น เราจำเป็นต้องโคลนค่าในฟิลด์ query และ file_path เพื่อให้ Config ได้รับสิทธิ์เป็นเจ้าของข้อมูลเหล่านั้นอย่างแท้จริง

ด้วยความรู้เรื่องอิเทอเรเตอร์ที่เราเพิ่งได้เรียนรู้ไป เราสามารถปรับเปลี่ยนฟังก์ชัน build ให้รับสิทธิ์ความเป็นเจ้าของของอิเทอเรเตอร์เข้ามาเป็นอาร์กิวเมนต์โดยตรงแทนการยืมข้อมูลผ่านสไลซ์ และนำความสามารถของอิเทอเรเตอร์มาใช้งานแทนโค้ดเดิมที่ต้องคอยตรวจนับความยาวของสไลซ์และเข้าถึงข้อมูลด้วยดัชนี ซึ่งช่วยให้โค้ดของ Config::build สื่อความหมายและเจตนาในการทำงานได้ชัดเจนยิ่งขึ้น

และเมื่อ Config::build ได้รับสิทธิ์ความเป็นเจ้าของในตัวอิเทอเรเตอร์ และไม่ต้องเข้าถึงข้อมูลผ่านดัชนีที่เกิดจากการยืมอีกต่อไป เราจึงสามารถย้ายค่า (move) ของ String ออกจากอิเทอเรเตอร์เข้าไปเก็บไว้ใน Config ได้โดยตรง โดยไม่ต้องเรียกใช้ clone เพื่อจัดสรรหน่วยความจำใหม่อีกเลย

การใช้อิเทอเรเตอร์ที่ถูกคืนกลับโดยตรง

เปิดไฟล์ src/main.rs ของโปรเจกต์ I/O ของคุณ ซึ่งควรมีหน้าตาดังนี้:

ชื่อไฟล์: 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| {
        eprintln!("Problem parsing arguments: {err}");
        process::exit(1);
    });

    // --snip--

    if let Err(e) = run(config) {
        eprintln!("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(())
}

ก่อนอื่น เราจะเปลี่ยนจุดเริ่มต้นของฟังก์ชัน main ที่เรามีในลิสติ้ง 12-24 เป็นโค้ดในลิสติ้ง 13-18 ซึ่งครั้งนี้ใช้อิเทอเรเตอร์ โค้ดนี้จะยังไม่คอมไพล์จนกว่าเราจะอัปเดต Config::build ด้วยเช่นกัน

use std::env;
use std::error::Error;
use std::fs;
use std::process;

use minigrep::{search, search_case_insensitive};

fn main() {
    let config = Config::build(env::args()).unwrap_or_else(|err| {
        eprintln!("Problem parsing arguments: {err}");
        process::exit(1);
    });

    // --snip--

    if let Err(e) = run(config) {
        eprintln!("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(())
}

ฟังก์ชัน env::args ส่งคืนค่าเป็นอิเทอเรเตอร์! แทนที่เราจะรวบรวมค่าจากอิเทอเรเตอร์เก็บลงในเวกเตอร์แล้วค่อยส่งสไลซ์ไปให้ Config::build ตอนนี้เราสามารถส่งสิทธิ์ความเป็นเจ้าของของอิเทอเรเตอร์ที่ได้จาก env::args ให้กับ Config::build ได้โดยตรงเลย

ต่อไป เราต้องอัปเดตนิยามของ Config::build มาปรับเปลี่ยนซิกเนเจอร์ของ Config::build ให้เป็นดังลิสติ้ง 13-19 กันครับ โค้ดนี้จะยังคอมไพล์ไม่ผ่าน เนื่องจากเรายังไม่ได้ปรับปรุงเนื้อหาภายในฟังก์ชัน

use std::env;
use std::error::Error;
use std::fs;
use std::process;

use minigrep::{search, search_case_insensitive};

fn main() {
    let config = Config::build(env::args()).unwrap_or_else(|err| {
        eprintln!("Problem parsing arguments: {err}");
        process::exit(1);
    });

    if let Err(e) = run(config) {
        eprintln!("Application error: {e}");
        process::exit(1);
    }
}

pub struct Config {
    pub query: String,
    pub file_path: String,
    pub ignore_case: bool,
}

impl Config {
    fn build(
        mut args: impl Iterator<Item = String>,
    ) -> Result<Config, &'static str> {
        // --snip--
        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(())
}

เอกสารของไลบรารีมาตรฐานสำหรับฟังก์ชัน env::args ระบุว่า ชนิดข้อมูลของอิเทอเรเตอร์ที่ส่งคืนกลับมาคือ std::env::Args ซึ่งชนิดข้อมูลนี้ได้อิมพลีเมนต์เทรต Iterator และส่งคืนสมาชิกออกมาเป็นชนิด String

เราได้อัปเดตซิกเนเจอร์ของฟังก์ชัน Config::build เพื่อให้พารามิเตอร์ args มีชนิดข้อมูลแบบเจเนอริกที่มีข้อกำหนดเทรต (trait bound) เป็น impl Iterator<Item = String> แทนที่จะเป็น &[String] การใช้ไวยากรณ์ impl Trait ที่เราได้เรียนรู้ในหัวข้อ“การใช้เทรตเป็นพารามิเตอร์” ของบทที่ 10 หมายความว่า args สามารถเป็นชนิดข้อมูลใดๆ ก็ได้ที่อิมพลีเมนต์เทรต Iterator และส่งคืนสมาชิกเป็นชนิด String

และเนื่องจากเราได้รับสิทธิ์ความเป็นเจ้าของใน args เข้ามา และเราจำเป็นต้องแก้ไขสถานะภายในของ args ผ่านการวนซ้ำ เราจึงต้องใส่คำสงวน mut กำกับไว้หน้าพารามิเตอร์ args เพื่อทำให้มันเปลี่ยนแปลงค่าได้

การใช้เมธอดของเทรต Iterator

ต่อไป เราจะปรับปรุงโค้ดภายในบอดี้ของ Config::build เนื่องจากเรารู้ว่า args อิมพลีเมนต์เทรต Iterator เราจึงสามารถเรียกใช้เมธอด next บนมันได้โดยตรง! ลิสติ้ง 13-20 แสดงการปรับปรุงโค้ดจากลิสติ้ง 12-23 ให้เปลี่ยนมาใช้เมธอด next

use std::env;
use std::error::Error;
use std::fs;
use std::process;

use minigrep::{search, search_case_insensitive};

fn main() {
    let config = Config::build(env::args()).unwrap_or_else(|err| {
        eprintln!("Problem parsing arguments: {err}");
        process::exit(1);
    });

    if let Err(e) = run(config) {
        eprintln!("Application error: {e}");
        process::exit(1);
    }
}

pub struct Config {
    pub query: String,
    pub file_path: String,
    pub ignore_case: bool,
}

impl Config {
    fn build(
        mut args: impl Iterator<Item = String>,
    ) -> Result<Config, &'static str> {
        args.next();

        let query = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a query string"),
        };

        let file_path = match args.next() {
            Some(arg) => arg,
            None => return Err("Didn't get a file path"),
        };

        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(())
}

จำไว้ว่าค่าแรกในค่าที่คืนกลับของ env::args คือชื่อของโปรแกรม เราต้องการข้ามค่านั้นและไปยังค่าถัดไป ดังนั้นก่อนอื่นเราเรียก next และไม่ทำอะไรกับค่าที่คืนกลับ จากนั้นเราเรียก next เพื่อดึงค่าที่เราต้องการใส่ในฟิลด์ query ของ Config หาก next คืน Some เราใช้ match เพื่อแยกค่าออกมา หากมันคืน None หมายความว่าให้อาร์กิวเมนต์มาไม่เพียงพอ และเราคืนค่าออกก่อนกำหนดด้วยค่า Err เราทำเช่นเดียวกันกับค่า file_path

ทำให้โค้ดชัดเจนขึ้นด้วยตัวปรับอิเทอเรเตอร์

เรายังใช้ประโยชน์จากอิเทอเรเตอร์ในฟังก์ชัน search ในโปรเจกต์ I/O ของเราได้ด้วย ซึ่งถูกจำลองขึ้นใหม่ที่นี่ในลิสติ้ง 13-21 ตามที่มีในลิสติ้ง 12-19

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 one_result() {
        let query = "duct";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.";

        assert_eq!(vec!["safe, fast, productive."], search(query, contents));
    }
}

เราสามารถเขียนโค้ดนี้ให้กระชับและอ่านง่ายยิ่งขึ้นได้โดยใช้เมธอดตัวปรับอิเทอเรเตอร์ (iterator adaptors) ซึ่งช่วยให้เราไม่ต้องสร้างเวกเตอร์ชั่วคราว results ที่เปลี่ยนแปลงค่าได้อีกต่อไป ในแนวทางการเขียนโปรแกรมเชิงฟังก์ชัน (functional programming) มักนิยมลดการใช้สถานะที่เปลี่ยนแปลงค่าได้ (mutable state) ให้เหลือน้อยที่สุดเพื่อให้โค้ดอ่านเข้าใจได้ชัดเจนยิ่งขึ้น การกำจัดสถานะที่เปลี่ยนแปลงได้นี้ยังช่วยเปิดทางให้เราสามารถขยายฟังก์ชันการทำงานในอนาคต เช่น การค้นหาแบบขนาน (parallel search) ได้อย่างง่ายดาย เพราะเราไม่ต้องกังวลเรื่องการจัดการสิทธิ์เข้าถึงเวกเตอร์ results พร้อมกัน ลิสติ้ง 13-22 แสดงการปรับปรุงโค้ดดังกล่าว

pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    contents
        .lines()
        .filter(|line| line.contains(query))
        .collect()
}

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)
        );
    }
}

ย้อนนึกว่าจุดประสงค์ของฟังก์ชัน search คือการค้นหาและส่งคืนทุกบรรทัดใน contents ที่มี query อยู่ คล้ายกับตัวอย่าง filter ในลิสติ้ง 13-16 โค้ดนี้ใช้ตัวปรับ filter เพื่อคัดกรองเฉพาะบรรทัดที่ line.contains(query) คืน true จากนั้นเราเก็บบรรทัดที่ตรงกันไว้ในเวกเตอร์อีกตัวด้วย collect ดูเรียบง่ายและกระชับขึ้นมากเลยใช่ไหมครับ! คุณสามารถนำแนวคิดเดียวกันนี้ไปปรับใช้กับฟังก์ชัน search_case_insensitive เพื่อให้ทำงานผ่านเมธอดของอิเทอเรเตอร์ได้เช่นกัน

สำหรับการปรับปรุงเพิ่มเติม ให้ลองปรับให้ฟังก์ชัน search ส่งคืนอิเทอเรเตอร์ออกมาโดยตรง โดยตัดการเรียก collect ออก และเปลี่ยนชนิดของค่าที่ส่งกลับเป็น impl Iterator<Item = &'a str> ซึ่งจะทำให้ฟังก์ชันกลายเป็นตัวปรับอิเทอเรเตอร์ไปในตัว (โปรดสังเกตว่าคุณจะต้องอัปเดตโค้ดในส่วนของเทสต์ตามไปด้วย!) ลองค้นหาในไฟล์ขนาดใหญ่โดยใช้เครื่องมือ minigrep ของคุณก่อนและหลังการเปลี่ยนแปลงนี้เพื่อสังเกตความแตกต่างของพฤติกรรม: ก่อนการปรับปรุง โปรแกรมจะไม่พิมพ์ผลลัพธ์ใดๆ จนกว่าจะรวบรวมผลลัพธ์ทั้งหมดเสร็จ แต่หลังการเปลี่ยนแปลง ผลลัพธ์จะถูกพิมพ์ทันทีที่พบบรรทัดที่ตรงกันแต่ละบรรทัด เพราะลูป for ในฟังก์ชัน run สามารถใช้ประโยชน์จากการประเมินผลตามความต้องการ (lazy evaluation) ของอิเทอเรเตอร์ได้ทันที

การเลือกระหว่างลูปกับอิเทอเรเตอร์

คำถามเชิงตรรกะข้อถัดไปคือ แล้วคุณควรเลือกเขียนโค้ดแบบใดในโปรเจกต์ของคุณเองและเพราะเหตุใด: ระหว่างการอิมพลีเมนต์ต้นฉบับในลิสติ้ง 13-21 หรือเวอร์ชันที่ใช้อิเทอเรเตอร์ในลิสติ้ง 13-22 (สมมติว่าเรารวบรวมผลลัพธ์ทั้งหมดก่อนส่งคืน แทนที่จะส่งคืนอิเทอเรเตอร์) โปรแกรมเมอร์ Rust ส่วนใหญ่ชอบใช้สไตล์อิเทอเรเตอร์มากกว่า ในตอนแรกอาจต้องใช้เวลาปรับตัวเพื่อทำความเข้าใจอยู่บ้าง แต่เมื่อคุณคุ้นเคยกับตัวปรับอิเทอเรเตอร์ต่างๆ และการทำงานของพวกมันแล้ว โค้ดที่ใช้อิเทอเรเตอร์จะอ่านและทำความเข้าใจได้ง่ายกว่ามาก แทนที่จะต้องมาคอยพะวงกับรายละเอียดการจัดการลูปและการสร้างเวกเตอร์ใหม่ โค้ดจะมุ่งเน้นไปที่เป้าหมายระดับสูงของการประมวลผลโดยตรง ซึ่งช่วยซ่อนรายละเอียดทางเทคนิคที่ซ้ำซากออกไป และทำให้เห็นเจตนาสำคัญของโค้ดได้ง่ายขึ้น เช่น เงื่อนไขการกรองข้อมูลที่สมาชิกแต่ละตัวในอิเทอเรเตอร์ต้องผ่าน

แต่คำถามคือ ทั้งสองวิธีนี้มีประสิทธิภาพเทียบเท่ากันจริงหรือไม่? ตามสัญชาตญาณ หลายคนอาจคิดว่าลูปในระดับล่างน่าจะทำงานได้เร็วกว่า ในหัวข้อถัดไปเราจะมาพูดคุยถึงเรื่องประสิทธิภาพกันครับ