ปรับปรุงโปรเจกต์ 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 ส่วนใหญ่ชอบใช้สไตล์อิเทอเรเตอร์มากกว่า ในตอนแรกอาจต้องใช้เวลาปรับตัวเพื่อทำความเข้าใจอยู่บ้าง แต่เมื่อคุณคุ้นเคยกับตัวปรับอิเทอเรเตอร์ต่างๆ และการทำงานของพวกมันแล้ว โค้ดที่ใช้อิเทอเรเตอร์จะอ่านและทำความเข้าใจได้ง่ายกว่ามาก แทนที่จะต้องมาคอยพะวงกับรายละเอียดการจัดการลูปและการสร้างเวกเตอร์ใหม่ โค้ดจะมุ่งเน้นไปที่เป้าหมายระดับสูงของการประมวลผลโดยตรง ซึ่งช่วยซ่อนรายละเอียดทางเทคนิคที่ซ้ำซากออกไป และทำให้เห็นเจตนาสำคัญของโค้ดได้ง่ายขึ้น เช่น เงื่อนไขการกรองข้อมูลที่สมาชิกแต่ละตัวในอิเทอเรเตอร์ต้องผ่าน
แต่คำถามคือ ทั้งสองวิธีนี้มีประสิทธิภาพเทียบเท่ากันจริงหรือไม่? ตามสัญชาตญาณ หลายคนอาจคิดว่าลูปในระดับล่างน่าจะทำงานได้เร็วกว่า ในหัวข้อถัดไปเราจะมาพูดคุยถึงเรื่องประสิทธิภาพกันครับ