เพิ่มฟังก์ชันการทำงานด้วยการพัฒนาแบบขับเคลื่อนด้วยเทสต์
เมื่อเราแยกตรรกะการค้นหามาไว้ใน src/lib.rs ต่างหากจากฟังก์ชัน main แล้ว การเขียนเทสต์สำหรับฟังก์ชันการทำงานหลักของโค้ดเราจึงง่ายขึ้นมาก เราสามารถเรียกใช้ฟังก์ชันโดยตรงพร้อมส่งอาร์กิวเมนต์ต่าง ๆ แล้วตรวจสอบค่าที่ส่งกลับมาได้ โดยไม่ต้องสั่งรันโปรแกรมไบนารีของเราจากบรรทัดคำสั่ง
ในหัวข้อนี้ เราจะเพิ่มตรรกะการค้นหาให้กับโปรแกรม minigrep โดยใช้กระบวนการพัฒนาแบบขับเคลื่อนด้วยเทสต์ (test-driven development หรือ TDD) ซึ่งมีขั้นตอนดังต่อไปนี้:
- เขียนเทสต์ที่ล้มเหลว แล้วรันดูเพื่อให้แน่ใจว่ามันล้มเหลวด้วยเหตุผลที่คุณคาดไว้จริง ๆ
- เขียนหรือแก้ไขโค้ดเพียงพอที่จะทำให้เทสต์ใหม่นั้นผ่าน
- รีแฟกเตอร์ (refactor) โค้ดที่คุณเพิ่งเพิ่มหรือแก้ไข และตรวจสอบให้แน่ใจว่าเทสต์ยังคงผ่านอยู่
- ทำซ้ำตั้งแต่ขั้นตอนที่ 1!
แม้ว่า TDD จะเป็นเพียงหนึ่งในหลาย ๆ วิธีในการพัฒนาซอฟต์แวร์ แต่มันก็ช่วยชี้นำการออกแบบโค้ดได้เป็นอย่างดี การเขียนเทสต์ก่อนเขียนโค้ดที่ทำให้เทสต์ผ่าน จะช่วยรักษาความครอบคลุมของการทดสอบ (test coverage) ให้อยู่ในระดับสูงตลอดทั้งกระบวนการ
เราจะใช้แนวทาง TDD ในการอิมพลีเมนต์ฟังก์ชันการทำงานที่จะค้นหาสตริงคำค้น (query) ในเนื้อหาของไฟล์จริง ๆ และสร้างรายการบรรทัดที่ตรงกับคำค้นนั้น โดยเราจะเพิ่มฟังก์ชันการทำงานนี้ไว้ในฟังก์ชันชื่อ search
การเขียนเทสต์ที่ล้มเหลว
ใน src/lib.rs เราจะเพิ่มมอดูล tests พร้อมกับฟังก์ชันเทสต์ ดังที่เราได้ทำไปในบทที่ 11 ฟังก์ชันเทสต์นี้จะระบุพฤติกรรมที่เราต้องการให้ฟังก์ชัน search มี นั่นคือ: รับคำค้นและข้อความที่ต้องการค้นหา แล้วส่งกลับเฉพาะบรรทัดจากข้อความที่มีคำค้นนั้นอยู่ ลิสติ้ง 12-15 แสดงให้เห็นเทสต์นี้
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
unimplemented!();
}
// --snip--
#[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));
}
}
เทสต์นี้จะค้นหาสตริง "duct" โดยข้อความที่เราค้นหานั้นมีสามบรรทัด ซึ่งมีเพียงบรรทัดเดียวเท่านั้นที่มีคำว่า "duct" (โปรดสังเกตว่าเครื่องหมายแบ็กสแลชหลังเครื่องหมายคำพูดเปิดบอกให้ Rust ทราบว่าไม่ต้องใส่ตัวอักษรขึ้นบรรทัดใหม่ที่จุดเริ่มต้นของสตริงลิเทอรัลนี้) เราใช้คำสั่งยืนยัน (assert) ว่าค่าที่ฟังก์ชัน search ส่งกลับมานั้นมีเฉพาะบรรทัดที่เราคาดหวังไว้
หากเรารันเทสต์นี้ ตอนนี้มันจะล้มเหลวเพราะมาโคร unimplemented! จะแพนิก (panic) ด้วยข้อความ “not implemented” ตามหลักการของ TDD เราจะค่อย ๆ ก้าวทีละขั้นโดยเพิ่มโค้ดให้เพียงพอที่จะทำให้ฟังก์ชันไม่แพนิกเมื่อถูกเรียกใช้งาน ซึ่งทำได้โดยนิยามฟังก์ชัน search ให้ส่งกลับเวกเตอร์ว่างเสมอ ดังที่แสดงในลิสติ้ง 12-16 จากนั้นเทสต์จะคอมไพล์ผ่าน แต่จะล้มเหลวในการทดสอบเนื่องจากเวกเตอร์ว่างไม่ตรงกับเวกเตอร์ที่มีบรรทัด "safe, fast, productive."
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
vec![]
}
#[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));
}
}
คราวนี้เรามาทำความเข้าใจกันว่าทำไมเราต้องระบุไลฟ์ไทม์ (lifetime) 'a อย่างชัดแจ้งในซิกเนเจอร์ของ search และใช้ไลฟ์ไทม์นั้นกับอาร์กิวเมนต์ contents รวมถึงค่าที่ส่งกลับด้วย ดังที่จำกันได้จากบทที่ 10 ว่าพารามิเตอร์ไลฟ์ไทม์จะระบุว่าไลฟ์ไทม์ของอาร์กิวเมนต์ตัวใดเชื่อมโยงกับไลฟ์ไทม์ของค่าที่ส่งกลับ ในกรณีนี้ เราระบุว่าเวกเตอร์ที่ส่งกลับควรบรรจุสตริงสไลซ์ที่อ้างอิงไปยังสไลซ์ของอาร์กิวเมนต์ contents (ไม่ใช่ของอาร์กิวเมนต์ query)
กล่าวอีกนัยหนึ่งคือ เราบอกให้ Rust ทราบว่าข้อมูลที่ฟังก์ชัน search ส่งกลับมานั้นจะมีอายุยืนยาวเท่ากับข้อมูลที่ส่งเข้ามาในฟังก์ชัน search ผ่านทางอาร์กิวเมนต์ contents จุดนี้สำคัญมาก! ข้อมูลที่ถูกสไลซ์_อ้างถึง_จะต้องมีอายุอยู่จริงเพื่อให้เรเฟอเรนซ์นั้นยังคงถูกต้องและใช้งานได้ หากคอมไพเลอร์สันนิษฐานว่าเรากำลังสร้างสตริงสไลซ์จาก query แทนที่จะเป็น contents การตรวจสอบความปลอดภัยของมันก็จะผิดพลาดไป
หากเราลืมระบุไลฟ์ไทม์แล้วลองคอมไพล์ฟังก์ชันนี้ เราจะได้รับข้อผิดพลาดดังนี้:
$ cargo build
Compiling minigrep v0.1.0 (file:///projects/minigrep)
error[E0106]: missing lifetime specifier
--> src/lib.rs:1:51
|
1 | pub fn search(query: &str, contents: &str) -> Vec<&str> {
| ---- ---- ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `query` or `contents`
help: consider introducing a named lifetime parameter
|
1 | pub fn search<'a>(query: &'a str, contents: &'a str) -> Vec<&'a str> {
| ++++ ++ ++ ++
For more information about this error, try `rustc --explain E0106`.
error: could not compile `minigrep` (lib) due to 1 previous error
Rust ไม่อาจทราบได้เองว่าเราต้องการให้อาร์กิวเมนต์ตัวใดในสองตัวนี้เชื่อมโยงกับเอาต์พุต เราจึงต้องบอกมันอย่างชัดแจ้ง โปรดสังเกตว่าข้อความช่วยเหลือแนะนำให้ระบุพารามิเตอร์ไลฟ์ไทม์เดียวกันกับทุกพารามิเตอร์และชนิดข้อมูลของเอาต์พุต ซึ่งนั่นไม่ถูกต้อง! เนื่องจาก contents เป็นพารามิเตอร์ที่เก็บข้อความทั้งหมดของเรา และเราต้องการส่งกลับส่วนต่าง ๆ ของข้อความนั้นที่ตรงกับเงื่อนไข เราจึงรู้ว่า contents เป็นพารามิเตอร์เพียงตัวเดียวที่ควรเชื่อมโยงกับค่าที่ส่งกลับโดยใช้ไวยากรณ์ไลฟ์ไทม์
ภาษาโปรแกรมอื่น ๆ มักไม่กำหนดให้คุณต้องเชื่อมโยงอาร์กิวเมนต์เข้ากับค่าที่ส่งกลับในซิกเนเจอร์ แต่เมื่อคุณคุ้นเคยไปเรื่อย ๆ คุณจะพบว่าเรื่องนี้ไม่ได้ยากอย่างที่คิด คุณอาจลองเปรียบเทียบตัวอย่างนี้กับตัวอย่างในหัวข้อ“การตรวจสอบความถูกต้องของเรเฟอเรนซ์ด้วยไลฟ์ไทม์” ในบทที่ 10 เพิ่มเติมได้
การเขียนโค้ดให้เทสต์ผ่าน
ตอนนี้เทสต์ของเรายังคงล้มเหลวอยู่เพราะเราส่งกลับเวกเตอร์ว่างเสมอ เพื่อแก้ไขปัญหานี้และอิมพลีเมนต์ฟังก์ชัน search ให้สมบูรณ์ โปรแกรมของเราต้องทำตามขั้นตอนดังต่อไปนี้:
- วนซ้ำผ่านแต่ละบรรทัดของเนื้อหา
- ตรวจสอบว่าบรรทัดนั้นมีสตริงคำค้น (query) ของเราอยู่หรือไม่
- ถ้ามี ให้เพิ่มบรรทัดนั้นลงในรายการของค่าที่เราจะส่งกลับ
- ถ้าไม่มี ก็ไม่ต้องทำอะไร
- ส่งกลับรายการของผลลัพธ์ที่ตรงกับคำค้น
เรามาลงมือทำทีละขั้นตอนกัน โดยเริ่มจากการวนซ้ำผ่านแต่ละบรรทัดก่อน
การวนซ้ำผ่านบรรทัดด้วยเมธอด lines
Rust มีเมธอดที่เป็นประโยชน์มากในการวนซ้ำอ่านสตริงทีละบรรทัด ซึ่งตั้งชื่อไว้อย่างตรงไปตรงมาว่า lines และทำงานดังที่แสดงในลิสติ้ง 12-17 โปรดสังเกตว่าโค้ดนี้จะยังคอมไพล์ไม่ผ่านในตอนนี้
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
for line in contents.lines() {
// do something with line
}
}
#[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));
}
}
เมธอด lines จะส่งกลับค่าเป็นอิเทอเรเตอร์ (iterator) เราจะพูดถึงเรื่องอิเทอเรเตอร์อย่างละเอียดในบทที่ 13 แต่หากจำกันได้ คุณเคยเห็นวิธีใช้งานอิเทอเรเตอร์ในลักษณะนี้มาแล้วในลิสติ้ง 3-5 ซึ่งเราใช้ลูป for ร่วมกับอิเทอเรเตอร์เพื่อรันโค้ดกับแต่ละสมาชิกในคอลเลกชัน
การค้นหา query ในแต่ละบรรทัด
ขั้นต่อไป เราจะตรวจสอบว่าบรรทัดปัจจุบันมีสตริง query ของเราอยู่หรือไม่ โชคดีที่สตริงมีเมธอดที่มีประโยชน์มากชื่อ contains ซึ่งช่วยทำงานนี้ให้เราได้ทันที! ให้เพิ่มการเรียกใช้เมธอด contains เข้าไปในฟังก์ชัน search ดังแสดงในลิสติ้ง 12-18 โปรดทราบว่าโค้ดนี้จะยังคงคอมไพล์ไม่ผ่านเช่นกัน
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
for line in contents.lines() {
if line.contains(query) {
// do something with line
}
}
}
#[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));
}
}
ในตอนนี้ เรากำลังค่อย ๆ ทยอยสร้างการทำงานขึ้นมาทีละส่วน และเพื่อให้โค้ดคอมไพล์ผ่านได้ เราจำเป็นต้องส่งค่ากลับจากเนื้อในตามที่เราได้ระบุไว้ในซิกเนเจอร์ของฟังก์ชัน
การจัดเก็บบรรทัดที่ตรงกัน
และเพื่อทำให้ฟังก์ชันนี้เสร็จสมบูรณ์ เราต้องการวิธีจัดเก็บบรรทัดที่ตรงกับคำค้นเพื่อส่งกลับไป เราสามารถสร้างเวกเตอร์แบบเปลี่ยนแปลงค่าได้ (mutable vector) ไว้ก่อนลูป for แล้วเรียกใช้เมธอด push เพื่อนำแต่ละ line ไปเก็บไว้ในเวกเตอร์ จากนั้นเมื่อจบลูป for จึงค่อยส่งเวกเตอร์นั้นกลับไป ดังแสดงในลิสติ้ง 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));
}
}
ตอนนี้ฟังก์ชัน search ควรจะส่งกลับเฉพาะบรรทัดที่มี query เท่านั้น และเทสต์ของเราก็น่าจะผ่านแล้ว มาลองรันเทสต์กันดู:
$ cargo test
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished `test` profile [unoptimized + debuginfo] target(s) in 1.22s
Running unittests src/lib.rs (target/debug/deps/minigrep-9cd200e5fac0fc94)
running 1 test
test tests::one_result ... ok
test result: ok. 1 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
เทสต์ของเราผ่านแล้ว แปลว่าฟังก์ชันทำงานได้ถูกต้องตามที่ต้องการ!
ณ จุดนี้ เราอาจพิจารณาหาโอกาสในการรีแฟกเตอร์โค้ดของฟังก์ชันค้นหา โดยยังคงรักษาให้เทสต์ผ่านอยู่เสมอเพื่อให้มั่นใจว่าฟังก์ชันการทำงานยังคงเดิม โค้ดในฟังก์ชันค้นหานี้ก็ไม่ได้แย่อะไร แต่ยังไม่ได้ใช้ประโยชน์จากฟีเจอร์ที่ทรงพลังของอิเทอเรเตอร์ เราจะกลับมาดูตัวอย่างนี้อีกครั้งในบทที่ 13 ซึ่งเราจะได้เจาะลึกเรื่องอิเทอเรเตอร์และดูวิธีปรับปรุงโค้ดนี้ให้ดียิ่งขึ้น
ตอนนี้ทั้งโปรแกรมของเราควรจะทำงานได้สมบูรณ์แล้ว! มาลองทดสอบใช้งานกันจริง ๆ ดู โดยเริ่มจากคำที่ควรจะได้ผลลัพธ์กลับมาเพียงบรรทัดเดียวจากบทกวีของ Emily Dickinson นั่นคือคำว่า: frog
$ cargo run -- frog poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.38s
Running `target/debug/minigrep frog poem.txt`
How public, like a frog
ยอดเยี่ยม! คราวนี้มาลองค้นหาคำที่ตรงกับหลายบรรทัดดูบ้าง เช่นคำว่า body:
$ cargo run -- body poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep body poem.txt`
I'm nobody! Who are you?
Are you nobody, too?
How dreary to be somebody!
และสุดท้าย เพื่อให้แน่ใจว่าเราจะไม่พบบรรทัดใด ๆ เลยเมื่อค้นหาคำที่ไม่มีอยู่ในบทกวี เช่นคำว่า monomorphization:
$ cargo run -- monomorphization poem.txt
Compiling minigrep v0.1.0 (file:///projects/minigrep)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s
Running `target/debug/minigrep monomorphization poem.txt`
ยอดเยี่ยมมาก! เราได้สร้างเครื่องมือคลาสสิกฉบับย่อของเราเองขึ้นมาสำเร็จ และได้เรียนรู้อะไรมากมายเกี่ยวกับวิธีจัดโครงสร้างแอปพลิเคชัน นอกจากนี้เรายังได้เรียนรู้เกี่ยวกับการจัดการอินพุตและเอาต์พุตของไฟล์ ไลฟ์ไทม์ การทดสอบ และการแยกวิเคราะห์บรรทัดคำสั่ง
เพื่อปิดท้ายโปรเจกต์นี้ให้สมบูรณ์ เราจะสาธิตสั้น ๆ ถึงวิธีทำงานร่วมกับตัวแปรสภาพแวดล้อม (environment variable) และวิธีพิมพ์ข้อความไปยัง standard error ซึ่งทั้งสองสิ่งนี้มีประโยชน์อย่างยิ่งเมื่อคุณพัฒนาโปรแกรมบรรทัดคำสั่ง