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

รีแฟกเตอร์เพื่อปรับปรุงโครงสร้างและการจัดการข้อผิดพลาด

เพื่อพัฒนาโปรแกรมของเราให้ดียิ่งขึ้น เราจะมาแก้ไขปัญหา 4 ประการที่เกี่ยวข้องกับโครงสร้างของโปรแกรมและวิธีจัดการกับข้อผิดพลาดที่อาจเกิดขึ้น ประการแรก ในตอนนี้ฟังก์ชัน main ของเราต้องแบกรับภาระหน้าที่ 2 อย่างพร้อมกัน นั่นคือการแยกวิเคราะห์อาร์กิวเมนต์ (parse arguments) และการอ่านไฟล์ เมื่อโปรแกรมเติบโตขึ้น จำนวนหน้าที่แยกย่อยที่ฟังก์ชัน main ต้องดูแลก็จะเพิ่มขึ้นตามไปด้วย และเมื่อฟังก์ชันหนึ่งๆ มีความรับผิดชอบมากเกินไป มันจะกลายเป็นเรื่องยากต่อการทำความเข้าใจ ยากต่อการทดสอบ และยากที่จะแก้ไขโดยไม่ไปกระทบกระเทือนให้ส่วนอื่นๆ พัง ทางเลือกที่ดีที่สุดคือการแยกฟังก์ชันการทำงานออกจากกัน เพื่อให้แต่ละฟังก์ชันรับผิดชอบเพียงหน้าที่เดียวอย่างชัดเจน

ประเด็นนี้ยังเชื่อมโยงกับปัญหาประการที่สอง: แม้ว่าตัวแปร query และ file_path จะเป็นตัวแปรสำหรับกำหนดค่า (configuration) ของโปรแกรม แต่ตัวแปรอย่าง contents กลับถูกนำมาใช้เพื่อดำเนินตรรกะการทำงาน ยิ่งฟังก์ชัน main มีขนาดยาวขึ้นเท่าไร เราก็ยิ่งต้องประกาศตัวแปรเข้ามาไว้ในสโคปมากขึ้นเท่านั้น และยิ่งมีตัวแปรในสโคปมากเท่าใด การจะคอยติดตามจุดประสงค์ของแต่ละตัวแปรก็ยิ่งทำได้ยากขึ้น ทางที่ดีที่สุดคือการจัดกลุ่มตัวแปรที่ใช้กำหนดค่าเหล่านี้ไว้ในโครงสร้างเดียวกัน เพื่อให้วัตถุประสงค์ในการใช้งานมีความชัดเจน

ปัญหาประการที่สามคือ เราใช้ expect เพื่อพิมพ์ข้อความแจ้งเตือนเมื่อการอ่านไฟล์ล้มเหลว แต่ข้อความนั้นกลับพิมพ์เพียงแค่ Should have been able to read the file ทว่าการอ่านไฟล์อาจล้มเหลวได้จากหลายสาเหตุ เช่น ไฟล์อาจไม่มีอยู่จริง หรือเราอาจไม่มีสิทธิ์ (permission) ในการเปิดอ่านไฟล์นั้น ในตอนนี้ ไม่ว่าจะเกิดปัญหาจากสาเหตุใด โปรแกรมก็จะพิมพ์ข้อความเดิมซ้ำๆ ออกมา ซึ่งไม่ได้ให้ข้อมูลที่เป็นประโยชน์แก่ผู้ใช้งานเลยแม้แต่น้อย!

ประการที่สี่ เราใช้ expect ในการจัดการข้อผิดพลาด ซึ่งหากผู้ใช้สั่งรันโปรแกรมโดยระบุอาร์กิวเมนต์ไม่ครบถ้วน พวกเขาจะได้รับข้อผิดพลาด index out of bounds จาก Rust ซึ่งไม่ได้อธิบายสาเหตุของปัญหาให้ผู้ใช้เข้าใจได้อย่างชัดเจน ทางออกที่ดีที่สุดคือการรวบรวมโค้ดจัดการข้อผิดพลาด (error handling) ทั้งหมดไว้ที่จุดเดียวกัน เพื่อให้ผู้ที่จะเข้ามาดูแลโค้ดในอนาคตมีจุดให้ตรวจสอบเพียงจุดเดียวหากจำเป็นต้องแก้ไขตรรกะการจัดการข้อผิดพลาด และการรวมโค้ดจัดการข้อผิดพลาดไว้ในที่เดียวยังช่วยรับประกันว่าเราจะสามารถพิมพ์ข้อความที่สื่อความหมายและมีประโยชน์ต่อผู้ใช้งานจริงได้เสมอ

เรามาจัดการกับปัญหาทั้ง 4 ประการนี้ด้วยการรีแฟกเตอร์ (refactor) โครงสร้างโปรเจกต์ของเรากัน

การแยกความรับผิดชอบในโปรเจกต์ไบนารี

ปัญหาเรื่องโครงสร้างจากการมอบหมายหน้าที่ความรับผิดชอบหลายอย่างให้ฟังก์ชัน main ถือเป็นเรื่องที่พบได้ทั่วไปในโปรเจกต์ไบนารี ด้วยเหตุนี้ นักพัฒนา Rust จำนวนมากจึงพบว่า การแยกแยะขอบเขตความรับผิดชอบ (separation of concerns) ของโปรแกรมไบนารีให้เป็นสัดส่วนนั้นมีประโยชน์อย่างยิ่งเมื่อฟังก์ชัน main เริ่มมีขนาดใหญ่ขึ้น โดยกระบวนการนี้จะประกอบด้วยขั้นตอนดังต่อไปนี้:

  • แยกโปรแกรมของคุณออกเป็นไฟล์ main.rs และไฟล์ lib.rs แล้วย้ายตรรกะการทำงานหลักของโปรแกรมไปไว้ใน lib.rs
  • ตราบใดที่ตรรกะการแยกวิเคราะห์อาร์กิวเมนต์คอมมานด์ไลน์ยังคงมีขนาดเล็ก มันก็สามารถอยู่ในฟังก์ชัน main ต่อไปได้
  • เมื่อตรรกะการแยกวิเคราะห์คอมมานด์ไลน์เริ่มมีความซับซ้อน ให้แยกมันออกจากฟังก์ชัน main ไปสร้างเป็นฟังก์ชันหรือชนิดข้อมูลต่างหาก

หน้าที่ความรับผิดชอบที่ยังคงเหลืออยู่ในฟังก์ชัน main หลังผ่านกระบวนการนี้ ควรจำกัดอยู่เพียงเรื่องต่อไปนี้เท่านั้น:

  • การเรียกใช้ตรรกะแยกวิเคราะห์คอมมานด์ไลน์ด้วยค่าอาร์กิวเมนต์
  • การตั้งค่าคอนฟิกูเรชันอื่นๆ ที่เกี่ยวข้อง
  • การเรียกใช้ฟังก์ชัน run ใน lib.rs
  • การจัดการข้อผิดพลาดในกรณีที่ฟังก์ชัน run ส่งคืนข้อผิดพลาดกลับมา

รูปแบบ (pattern) นี้คือการแยกความรับผิดชอบอย่างชัดเจน: โดย main.rs จะดูแลเรื่องการเริ่มต้นสั่งทำงานโปรแกรม ส่วน lib.rs จะดูแลตรรกะการทำงานทั้งหมดของโปรแกรม และเนื่องจากคุณไม่สามารถเขียนเทสต์เพื่อทดสอบฟังก์ชัน main ได้โดยตรง โครงสร้างนี้จึงเปิดโอกาสให้คุณสามารถทดสอบตรรกะการทำงานทั้งหมดของโปรแกรมได้อย่างทั่วถึง เพราะตรรกะเหล่านั้นถูกย้ายออกจากฟังก์ชัน main มาอยู่ในไลบรารีแล้ว ทำให้โค้ดที่หลงเหลืออยู่ในฟังก์ชัน main มีขนาดกะทัดรัดพอที่จะตรวจสอบความถูกต้องได้เพียงแค่อ่านด้วยสายตา เรามาปรับปรุงโครงสร้างโปรแกรมของเราตามขั้นตอนเหล่านี้กัน

การแยกตัวแยกวิเคราะห์อาร์กิวเมนต์ออกมา

เราจะแยกฟังก์ชันการทำงานสำหรับแยกวิเคราะห์อาร์กิวเมนต์ออกมาเป็นฟังก์ชันใหม่เพื่อให้ main เรียกใช้ ลิสติ้ง 12-5 แสดงจุดเริ่มต้นใหม่ของฟังก์ชัน main ที่เรียกฟังก์ชันใหม่ชื่อ parse_config ซึ่งเราจะนิยามไว้ในไฟล์ src/main.rs

use std::env;
use std::fs;

fn main() {
    let args: Vec<String> = env::args().collect();

    let (query, file_path) = parse_config(&args);

    // --snip--

    println!("Searching for {query}");
    println!("In file {file_path}");

    let contents = fs::read_to_string(file_path)
        .expect("Should have been able to read the file");

    println!("With text:\n{contents}");
}

fn parse_config(args: &[String]) -> (&str, &str) {
    let query = &args[1];
    let file_path = &args[2];

    (query, file_path)
}

เรายังคงรวบรวมอาร์กิวเมนต์คอมมานด์ไลน์เข้ามาไว้ในเวกเตอร์เช่นเดิม แต่แทนที่จะกำหนดค่าอาร์กิวเมนต์ดัชนีที่ 1 ให้กับตัวแปร query และค่าดัชนีที่ 2 ให้กับตัวแปร file_path ภายในฟังก์ชัน main เราจะส่งเวกเตอร์ทั้งชุดไปยังฟังก์ชัน parse_config แทน ฟังก์ชัน parse_config จะเป็นผู้ดูแลตรรกะในการระบุว่าอาร์กิวเมนต์ใดควรเป็นของตัวแปรใด แล้วส่งค่าเหล่านั้นกลับคืนมาให้ main แม้เราจะยังคงประกาศตัวแปร query และ file_path ใน main อยู่ แต่ main ก็ไม่ต้องแบกรับหน้าที่ในการจับคู่อาร์กิวเมนต์คอมมานด์ไลน์เข้ากับตัวแปรต่างๆ อีกต่อไป

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

การจัดกลุ่มค่าการกำหนดค่า

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

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

ลิสติ้ง 12-6 แสดงการปรับปรุงฟังก์ชัน parse_config

use std::env;
use std::fs;

fn main() {
    let args: Vec<String> = env::args().collect();

    let config = parse_config(&args);

    println!("Searching for {}", config.query);
    println!("In file {}", config.file_path);

    let contents = fs::read_to_string(config.file_path)
        .expect("Should have been able to read the file");

    // --snip--

    println!("With text:\n{contents}");
}

struct Config {
    query: String,
    file_path: String,
}

fn parse_config(args: &[String]) -> Config {
    let query = args[1].clone();
    let file_path = args[2].clone();

    Config { query, file_path }
}

เราได้เพิ่ม struct ชื่อ Config ที่มีฟิลด์ query และ file_path โดยซิกเนเจอร์ของ parse_config ในตอนนี้ระบุว่าจะส่งคืนค่าเป็น Config ในเนื้อหาของ parse_config เดิมทีเราเคยส่งคืนสตริงสไลซ์ (string slice) ที่อ้างอิงไปยังค่า String ใน args แต่ตอนนี้เราได้นิยาม Config ให้ถือครองค่า String ที่เป็นเจ้าของข้อมูลเอง เนื่องจากตัวแปร args ในฟังก์ชัน main เป็นเจ้าของค่าของอาร์กิวเมนต์ และเพียงแค่เปิดให้ฟังก์ชัน parse_config ยืมค่าเหล่านั้นไปใช้งานเท่านั้น หาก Config พยายามเข้าครอบครองความเป็นเจ้าของค่าใน args โดยตรง ก็จะถือเป็นการละเมิดกฎการยืมของ Rust

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

ข้อแลกเปลี่ยนของการใช้ clone

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

เราได้อัปเดตฟังก์ชัน main ให้นำอินสแตนซ์ของ Config ที่ส่งคืนจาก parse_config ไปเก็บไว้ในตัวแปรชื่อ config และอัปเดตโค้ดส่วนที่เคยเรียกใช้ตัวแปร query และ file_path แยกกัน ให้เปลี่ยนมาเรียกใช้ผ่านฟิลด์ของ struct Config แทน

ในตอนนี้ โค้ดของเราสื่อสารได้อย่างชัดเจนแล้วว่า query และ file_path มีความเกี่ยวข้องกัน และมีวัตถุประสงค์เพื่อใช้กำหนดค่าการทำงานของโปรแกรม ไม่ว่าโค้ดส่วนใดที่ต้องการใช้ค่าเหล่านี้ ก็จะทราบได้ทันทีว่าจะค้นพบมันได้ในอินสแตนซ์ config ภายใต้ชื่อฟิลด์ที่ตรงกับจุดประสงค์การใช้งาน

การสร้างคอนสตรัคเตอร์ให้ Config

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

ดังนั้น ในเมื่อจุดประสงค์ของฟังก์ชัน parse_config คือการสร้างอินสแตนซ์ของ Config เราจึงสามารถเปลี่ยน parse_config จากฟังก์ชันธรรมดาให้กลายเป็นฟังก์ชันชื่อ new ที่ผูกอยู่กับ struct Config ได้ การปรับเปลี่ยนนี้จะช่วยให้โค้ดเป็นไปตามสำนวนนิยมของ Rust มากยิ่งขึ้น เช่นเดียวกับการสร้างอินสแตนซ์ของชนิดข้อมูลในไลบรารีมาตรฐานอย่าง String ด้วยคำสั่ง String::new การเปลี่ยน parse_config ให้เป็นฟังก์ชัน new ของ Config ก็จะทำให้เราสามารถสร้างอินสแตนซ์ของ Config ได้ด้วยคำสั่ง Config::new ลิสติ้ง 12-7 แสดงการปรับเปลี่ยนที่เราต้องทำ

use std::env;
use std::fs;

fn main() {
    let args: Vec<String> = env::args().collect();

    let config = Config::new(&args);

    println!("Searching for {}", config.query);
    println!("In file {}", config.file_path);

    let contents = fs::read_to_string(config.file_path)
        .expect("Should have been able to read the file");

    println!("With text:\n{contents}");

    // --snip--
}

// --snip--

struct Config {
    query: String,
    file_path: String,
}

impl Config {
    fn new(args: &[String]) -> Config {
        let query = args[1].clone();
        let file_path = args[2].clone();

        Config { query, file_path }
    }
}

เราได้อัปเดต main ตรงที่เราเคยเรียก parse_config ให้เรียก Config::new แทน เราเปลี่ยนชื่อ parse_config เป็น new และย้ายมันเข้าไปในบล็อก impl ซึ่งเชื่อมโยงฟังก์ชัน new กับ Config ลองคอมไพล์โค้ดนี้อีกครั้งเพื่อให้แน่ใจว่ามันทำงานได้

การแก้ไขการจัดการข้อผิดพลาด

คราวนี้เราจะมาปรับปรุงการจัดการข้อผิดพลาดให้รัดกุมยิ่งขึ้น ย้อนกลับไปก่อนหน้านี้ การพยายามเข้าถึงค่าในเวกเตอร์ args ที่ดัชนี 1 หรือ 2 จะทำให้โปรแกรมเกิดการแพนิก (panic) ทันทีหากเวกเตอร์มีสมาชิกน้อยกว่า 3 ตัว ลองรันโปรแกรมโดยไม่ใส่อาร์กิวเมนต์ใดๆ เลย จะได้ผลลัพธ์ดังนี้:

$ cargo run
   Compiling minigrep v0.1.0 (file:///projects/minigrep)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s
     Running `target/debug/minigrep`

thread 'main' (6023615) panicked at src/main.rs:27:21:
index out of bounds: the len is 1 but the index is 1
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

บรรทัด index out of bounds: the len is 1 but the index is 1 เป็นข้อความแสดงข้อผิดพลาดที่มุ่งหมายสำหรับโปรแกรมเมอร์ มันไม่ช่วยให้ผู้ใช้ปลายทางของเราเข้าใจว่าพวกเขาควรทำอะไรแทน มาลองแก้ปัญหานี้กันเลย

การปรับปรุงข้อความแสดงข้อผิดพลาด

ในลิสติ้ง 12-8 เราได้เพิ่มการตรวจสอบเงื่อนไขในฟังก์ชัน new เพื่อยืนยันว่าสไลซ์มีความยาวเพียงพอก่อนที่จะพยายามเข้าถึงดัชนี 1 และดัชนี 2 หากสไลซ์มีความยาวไม่พอ โปรแกรมจะแพนิกพร้อมแสดงข้อความแจ้งเตือนที่เข้าใจง่ายขึ้น

use std::env;
use std::fs;

fn main() {
    let args: Vec<String> = env::args().collect();

    let config = Config::new(&args);

    println!("Searching for {}", config.query);
    println!("In file {}", config.file_path);

    let contents = fs::read_to_string(config.file_path)
        .expect("Should have been able to read the file");

    println!("With text:\n{contents}");
}

struct Config {
    query: String,
    file_path: String,
}

impl Config {
    // --snip--
    fn new(args: &[String]) -> Config {
        if args.len() < 3 {
            panic!("not enough arguments");
        }
        // --snip--

        let query = args[1].clone();
        let file_path = args[2].clone();

        Config { query, file_path }
    }
}

โค้ดนี้คล้ายกับฟังก์ชัน Guess::new ที่เราเขียนในลิสติ้ง 9-13 ซึ่งเราเรียก panic! เมื่ออาร์กิวเมนต์ value อยู่นอกช่วงของค่าที่ถูกต้อง แทนที่จะตรวจสอบช่วงของค่าที่นี่ เราตรวจสอบว่าความยาวของ args อย่างน้อย 3 และส่วนที่เหลือของฟังก์ชันสามารถทำงานภายใต้สมมติฐานว่าเงื่อนไขนี้เป็นจริงได้ หาก args มีสมาชิกน้อยกว่าสามรายการ เงื่อนไขนี้จะเป็น true และเราเรียกมาโคร panic! เพื่อยุติโปรแกรมทันที

หลังจากเพิ่มโค้ดไม่กี่บรรทัดนี้ลงใน new ลองสั่งรันโปรแกรมโดยไม่ใส่อาร์กิวเมนต์อีกครั้ง เพื่อดูว่าข้อความข้อผิดพลาดเปลี่ยนไปอย่างไร:

$ cargo run
   Compiling minigrep v0.1.0 (file:///projects/minigrep)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s
     Running `target/debug/minigrep`

thread 'main' (6023776) panicked at src/main.rs:26:13:
not enough arguments
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

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

การคืนค่า Result แทนการเรียก panic!

เราสามารถปรับเปลี่ยนมาส่งคืนค่าชนิด Result ซึ่งจะบรรจุอินสแตนซ์ของ Config ในกรณีที่สำเร็จ และจะอธิบายสาเหตุของปัญหาในกรณีที่เกิดข้อผิดพลาด นอกจากนี้ เราจะเปลี่ยนชื่อฟังก์ชันจาก new เป็น build เนื่องจากนักพัฒนาส่วนใหญ่มักคาดหวังว่าฟังก์ชัน new จะต้องไม่ล้มเหลว เมื่อ Config::build ติดต่อสื่อสารกับ main เราสามารถใช้ชนิดข้อมูล Result เพื่อส่งสัญญาณเตือนว่าเกิดปัญหาขึ้นได้ จากนั้นเราจะปรับแก้ฟังก์ชัน main ให้แปลงวาเรียนต์ Err ออกมาเป็นข้อความแจ้งข้อผิดพลาดที่เหมาะสมกับผู้ใช้งาน โดยไม่มีข้อความรกรุงรังเกี่ยวกับ thread 'main' และ RUST_BACKTRACE ที่เกิดจากการเรียก panic! ติดมาด้วย

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

use std::env;
use std::fs;

fn main() {
    let args: Vec<String> = env::args().collect();

    let config = Config::new(&args);

    println!("Searching for {}", config.query);
    println!("In file {}", config.file_path);

    let contents = fs::read_to_string(config.file_path)
        .expect("Should have been able to read the file");

    println!("With text:\n{contents}");
}

struct Config {
    query: String,
    file_path: String,
}

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

ฟังก์ชัน build ของเราจะส่งคืนค่า Result ที่บรรจุอินสแตนซ์ของ Config ในกรณีสำเร็จ และบรรจุสตริงลิเทอรัลในกรณีที่เกิดข้อผิดพลาด โดยค่าข้อผิดพลาดของเราจะเป็นสตริงลิเทอรัลที่มีไลฟ์ไทม์เป็น 'static เสมอ

เราได้ทำการแก้ไขเนื้อหาของฟังก์ชัน 2 จุด: แทนที่จะเรียกใช้ panic! เมื่อผู้ใช้ส่งอาร์กิวเมนต์มาไม่ครบถ้วน ตอนนี้เราจะส่งคืนค่า Err แทน และเราได้ห่อหุ้มค่า Config ที่ส่งคืนไว้ภายใน Ok การเปลี่ยนแปลงเหล่านี้ทำให้การทำงานของฟังก์ชันสอดคล้องกับซิกเนเจอร์ชนิดข้อมูลใหม่ของมันอย่างสมบูรณ์

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

การเรียก Config::build และการจัดการข้อผิดพลาด

เพื่อจัดการกับกรณีที่เกิดข้อผิดพลาดและพิมพ์ข้อความที่เป็นมิตรต่อผู้ใช้งาน เราจำเป็นต้องอัปเดตฟังก์ชัน main ให้คอยจัดการกับค่า Result ที่ส่งคืนมาจาก Config::build ดังที่แสดงในลิสติ้ง 12-10 นอกจากนี้เราจะออกจากโปรแกรมคอมมานด์ไลน์ด้วยรหัสสถานะที่ไม่ใช่ศูนย์ (nonzero error code) โดยเขียนจัดการด้วยตนเองแทนการพึ่งพา panic! ทั้งนี้ รหัสสถานะการออกที่ไม่ใช่ศูนย์ถือเป็นธรรมเนียมปฏิบัติสากลเพื่อส่งสัญญาณบอกโปรเซสที่เรียกใช้โปรแกรมของเราว่า โปรแกรมได้ยุติการทำงานลงเนื่องจากเกิดข้อผิดพลาดขึ้น

use std::env;
use std::fs;
use std::process;

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

    // --snip--

    println!("Searching for {}", config.query);
    println!("In file {}", config.file_path);

    let contents = fs::read_to_string(config.file_path)
        .expect("Should have been able to read the file");

    println!("With text:\n{contents}");
}

struct Config {
    query: String,
    file_path: String,
}

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

ในลิสติ้งนี้ เราได้ใช้เมธอดที่เรายังไม่ได้อธิบายอย่างละเอียด นั่นคือ unwrap_or_else ซึ่งถูกนิยามไว้บน Result<T, E> ในไลบรารีมาตรฐาน การใช้ unwrap_or_else ช่วยให้เราสามารถกำหนดตรรกะการจัดการข้อผิดพลาดในแบบของเราเองได้โดยไม่ต้องเกิด panic! หากค่า Result เป็น Ok พฤติกรรมของเมธอดนี้จะเหมือนกับ unwrap คือจะแกะค่าภายในที่ Ok ห่อหุ้มไว้ออกมาให้ แต่หากค่านั้นเป็น Err เมธอดนี้จะเรียกใช้โค้ดที่อยู่ใน_โคลเชอร์_ (closure) ซึ่งเป็นฟังก์ชันนิรนามที่เรานิยามและส่งเป็นอาร์กิวเมนต์ให้กับ unwrap_or_else เราจะได้เรียนรู้เรื่องโคลเชอร์อย่างละเอียดในบทที่ 13 สำหรับตอนนี้ คุณเพียงแค่ต้องทราบว่า unwrap_or_else จะส่งค่าภายในของ Err ซึ่งในกรณีนี้คือสตริงสแตติก "not enough arguments" ที่เรากำหนดไว้ในลิสติ้ง 12-9 เข้ามายังโคลเชอร์ผ่านทางอาร์กิวเมนต์ err ที่อยู่ระหว่างเส้นแนวตั้ง ทำให้โค้ดในโคลเชอร์สามารถนำค่า err นี้ไปใช้งานได้

เราได้เพิ่มบรรทัด use ใหม่เพื่อนำเข้ามอดูล process จากไลบรารีมาตรฐาน โดยโค้ดในโคลเชอร์ที่จะทำงานเมื่อเกิดข้อผิดพลาดมีเพียง 2 บรรทัดเท่านั้น: บรรทัดแรกสั่งพิมพ์ค่า err ออกมา และบรรทัดถัดไปเรียกใช้คำสั่ง process::exit โดยฟังก์ชัน process::exit จะสั่งหยุดการทำงานของโปรแกรมในทันที และส่งคืนตัวเลขที่ระบุเป็นรหัสสถานะการออก สิ่งนี้คล้ายกับการจัดการที่ใช้ panic! ซึ่งเราใช้ในลิสติ้ง 12-8 แต่เราไม่ต้องเห็นเอาต์พุตเกินจำเป็นทั้งหมดอีกต่อไป มาลองกัน:

$ cargo run
   Compiling minigrep v0.1.0 (file:///projects/minigrep)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.48s
     Running `target/debug/minigrep`
Problem parsing arguments: not enough arguments

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

การแยกตรรกะออกจาก main

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

ลิสติ้ง 12-11 แสดงการปรับปรุงแบบค่อยเป็นค่อยไปเล็กๆ ด้วยการแยกฟังก์ชัน run ออกมา

use std::env;
use std::fs;
use std::process;

fn main() {
    // --snip--

    let args: Vec<String> = env::args().collect();

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

    println!("Searching for {}", config.query);
    println!("In file {}", config.file_path);

    run(config);
}

fn run(config: Config) {
    let contents = fs::read_to_string(config.file_path)
        .expect("Should have been able to read the file");

    println!("With text:\n{contents}");
}

// --snip--

struct Config {
    query: String,
    file_path: String,
}

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

ในตอนนี้ ฟังก์ชัน run ได้รวบรวมตรรกะการทำงานที่เหลือทั้งหมดจาก main เริ่มตั้งแต่การอ่านไฟล์ โดยฟังก์ชัน run จะรับอินสแตนซ์ของ Config เป็นอาร์กิวเมนต์

การคืนค่าข้อผิดพลาดจาก run

เมื่อตรรกะส่วนที่เหลือของโปรแกรมถูกแยกออกมาอยู่ในฟังก์ชัน run เรียบร้อยแล้ว เราก็สามารถปรับปรุงการจัดการข้อผิดพลาดให้ดียิ่งขึ้นได้ เช่นเดียวกับที่เราเคยทำกับ Config::build ในลิสติ้ง 12-9 แทนที่จะปล่อยให้โปรแกรมเกิดการแพนิกด้วยการเรียก expect เราจะให้ฟังก์ชัน run ส่งคืนค่า Result<T, E> เมื่อมีสิ่งใดผิดพลาด ซึ่งจะช่วยให้เราสามารถรวบรวมตรรกะการจัดการข้อผิดพลาดทั้งหมดไปไว้ที่ main ในรูปแบบที่เป็นมิตรต่อผู้ใช้งาน ลิสติ้ง 12-12 แสดงการเปลี่ยนแปลงที่เราต้องทำกับซิกเนเจอร์และเนื้อหาของฟังก์ชัน run

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

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

    println!("Searching for {}", config.query);
    println!("In file {}", config.file_path);

    run(config);
}

fn run(config: Config) -> Result<(), Box<dyn Error>> {
    let contents = fs::read_to_string(config.file_path)?;

    println!("With text:\n{contents}");

    Ok(())
}

struct Config {
    query: String,
    file_path: String,
}

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

เราได้ทำการเปลี่ยนแปลงสำคัญ 3 ประการด้วยกัน อย่างแรก เราเปลี่ยนชนิดข้อมูลที่ส่งคืนของฟังก์ชัน run เป็น Result<(), Box<dyn Error>> โดยเดิมทีฟังก์ชันนี้ส่งคืนยูนิตไทป์ (unit type) คือ () และเรายังคงค่านั้นไว้เป็นค่าที่ส่งคืนในกรณีที่เป็น Ok

สำหรับชนิดข้อผิดพลาด เราได้ใช้เทรตออบเจกต์ (trait object) คือ Box<dyn Error> (และเราได้นำเข้า std::error::Error สู่สโคปด้วยคำสั่ง use ที่ด้านบน) เราจะได้เรียนรู้เรื่องเทรตออบเจกต์อย่างละเอียดในบทที่ 18 สำหรับตอนนี้ ขอให้เข้าใจว่า Box<dyn Error> หมายความว่าฟังก์ชันจะส่งคืนชนิดข้อมูลใดๆ ก็ตามที่อิมพลีเมนต์เทรต Error โดยที่เราไม่ต้องเจาะจงระบุชนิดข้อมูลที่แน่นอน ซึ่งมอบความยืดหยุ่นในการส่งคืนข้อผิดพลาดที่อาจมีชนิดแตกต่างกันในแต่ละสถานการณ์ โดยคีย์เวิร์ด dyn ย่อมาจากคำว่า dynamic

ประการที่สอง เราได้ตัดการเรียกใช้ expect ออก แล้วแทนที่ด้วยตัวดำเนินการ ? ตามที่เราเคยเรียนรู้ในบทที่ 9 แทนที่จะเกิด panic! เมื่อมีข้อผิดพลาด ตัวดำเนินการ ? จะส่งต่อ (propagate) ค่าข้อผิดพลาดนั้นออกจากฟังก์ชันปัจจุบันเพื่อให้ฟังก์ชันผู้เรียกเป็นผู้จัดการแทน

ประการที่สาม ฟังก์ชัน run จะส่งคืนค่า Ok ในกรณีที่ทำงานสำเร็จ เนื่องจากเราได้ประกาศชนิดข้อมูลสำหรับกรณีสำเร็จในซิกเนเจอร์เป็น () เราจึงต้องห่อค่ายูนิตไทป์ไว้ภายใน Ok รูปแบบวากยสัมพันธ์ Ok(()) นี้อาจดูแปลกตาไปบ้างในตอนแรก แต่การใช้ () เช่นนี้ถือเป็นสำนวนนิยมใน Rust ที่บ่งบอกว่าเราเรียกใช้ฟังก์ชัน run เพื่อผลข้างเคียง (side effects) เท่านั้น โดยไม่ได้ต้องการค่าผลลัพธ์ใดๆ กลับคืนมา

เมื่อคุณสั่งรันโค้ดนี้ โปรแกรมจะสามารถคอมไพล์ผ่านได้ แต่จะแสดงคำเตือน (warning) ออกมา:

$ cargo run -- the poem.txt
   Compiling minigrep v0.1.0 (file:///projects/minigrep)
warning: unused `Result` that must be used
  --> src/main.rs:19:5
   |
19 |     run(config);
   |     ^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default
help: use `let _ = ...` to ignore the resulting value
   |
19 |     let _ = run(config);
   |     +++++++

warning: `minigrep` (bin "minigrep") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.71s
     Running `target/debug/minigrep the poem.txt`
Searching for the
In file poem.txt
With text:
I'm nobody! Who are you?
Are you nobody, too?
Then there's a pair of us - don't tell!
They'd banish us, you know.

How dreary to be somebody!
How public, like a frog
To tell your name the livelong day
To an admiring bog!

Rust กำลังเตือนว่าโค้ดของเราไม่ได้สนใจค่า Result ที่ได้รับมาเลย ซึ่งค่า Result นั้นอาจเป็นตัวบ่งบอกว่าเกิดข้อผิดพลาดขึ้น แต่เรากลับไม่ได้ตรวจสอบอะไร และคอมไพเลอร์จึงเตือนสติเราว่า เราน่าจะลืมเขียนโค้ดสำหรับจัดการข้อผิดพลาดตรงจุดนี้! มาแก้ไขปัญหานี้กันต่อเลย

การจัดการข้อผิดพลาดที่คืนกลับจาก run ใน main

เราจะตรวจสอบและจัดการกับข้อผิดพลาดโดยใช้เทคนิคที่คล้ายคลึงกับที่เราเคยใช้กับ Config::build ในลิสติ้ง 12-10 แต่มีความแตกต่างกันเล็กน้อย:

ชื่อไฟล์: src/main.rs

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

fn main() {
    // --snip--

    let args: Vec<String> = env::args().collect();

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

    println!("Searching for {}", config.query);
    println!("In file {}", config.file_path);

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

fn run(config: Config) -> Result<(), Box<dyn Error>> {
    let contents = fs::read_to_string(config.file_path)?;

    println!("With text:\n{contents}");

    Ok(())
}

struct Config {
    query: String,
    file_path: String,
}

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

เราเลือกใช้ if let แทน unwrap_or_else ในการตรวจสอบว่าฟังก์ชัน run ส่งคืนค่าเป็น Err หรือไม่ และสั่งเรียก process::exit(1) หากเกิดข้อผิดพลาดขึ้น เนื่องจากฟังก์ชัน run ไม่ได้ส่งคืนค่าที่เราต้องการนำมา unwrap เหมือนกรณีของ Config::build ที่ส่งคืนอินสแตนซ์ของ Config และเนื่องจากในกรณีสำเร็จ run จะส่งคืนเพียงแค่ () เราจึงสนใจเพียงแค่การตรวจจับข้อผิดพลาดเท่านั้น โดยไม่จำเป็นต้องใช้ unwrap_or_else เพื่อแกะเอาค่า () ออกมา

เนื้อหาการทำงานภายในบล็อก if let ก็จะเหมือนกับใน unwrap_or_else ทุกประการ: คือเราจะสั่งพิมพ์ข้อความข้อผิดพลาดออกมา แล้วสั่งปิดโปรแกรม

การแยกโค้ดออกเป็นเครตไลบรารี

โปรเจกต์ minigrep ของเราเริ่มเป็นรูปเป็นร่างและมีโครงสร้างที่ดีขึ้นมาก! คราวนี้เราจะทำการแยกไฟล์ src/main.rs โดยย้ายโค้ดบางส่วนไปไว้ในไฟล์ src/lib.rs ซึ่งจะช่วยให้เราสามารถเขียนชุดทดสอบให้กับโค้ดได้ และทำให้ไฟล์ src/main.rs มีภาระหน้าที่น้อยลง

เราจะย้ายโค้ดส่วนที่รับผิดชอบเรื่องการค้นหาข้อความไปไว้ใน src/lib.rs แทนที่จะอยู่ใน src/main.rs ซึ่งจะเปิดโอกาสให้เรา (หรือใครก็ตามที่นำไลบรารี minigrep ของเราไปใช้) สามารถเรียกใช้ฟังก์ชันค้นหานี้ในบริบทอื่นๆ นอกเหนือจากโปรแกรมไบนารี minigrep ได้

อันดับแรก เราจะนิยามซิกเนเจอร์ของฟังก์ชัน search ใน src/lib.rs ดังที่แสดงในลิสติ้ง 12-13 โดยใส่เนื้อหาชั่วคราวเป็นคำสั่งเรียกใช้มาโคร unimplemented! เราจะอธิบายซิกเนเจอร์นี้อย่างละเอียดอีกครั้งเมื่อเราเริ่มลงมือเขียนการทำงานจริง

pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    unimplemented!();
}

เราได้ใส่คีย์เวิร์ด pub ไว้หน้าการนิยามฟังก์ชัน เพื่อกำหนดให้ search กลายมาเป็นส่วนหนึ่งของ API สาธารณะในเครตไลบรารีของเรา ในตอนนี้เราจึงมีเครตไลบรารีที่พร้อมให้เครตไบนารีเรียกใช้งาน และพร้อมสำหรับการเขียนชุดทดสอบแล้ว!

ขั้นตอนถัดไป เราต้องนำโค้ดที่นิยามไว้ใน src/lib.rs เข้ามาสู่สโคปของเครตไบนารีใน src/main.rs แล้วเรียกใช้งาน ดังที่แสดงในลิสติ้ง 12-14

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

// --snip--
use minigrep::search;

fn main() {
    // --snip--
    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);
    }
}

// --snip--


struct Config {
    query: String,
    file_path: String,
}

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

    for line in search(&config.query, &contents) {
        println!("{line}");
    }

    Ok(())
}

เราเพิ่มคำสั่ง use minigrep::search; เพื่อนำฟังก์ชัน search จากเครตไลบรารีเข้ามาสู่สโคปของเครตไบนารี จากนั้นในฟังก์ชัน run แทนที่เราจะพิมพ์เนื้อหาทั้งหมดของไฟล์ออกมาเฉยๆ เราจะเรียกใช้ฟังก์ชัน search โดยส่งค่า config.query และ contents เข้าไปเป็นอาร์กิวเมนต์ แล้วฟังก์ชัน run จะใช้ลูป for วนพิมพ์แต่ละบรรทัดที่ฟังก์ชัน search ส่งคืนกลับมาซึ่งตรงกับคำค้นหา นอกจากนี้ จังหวะนี้ยังเป็นโอกาสอันดีที่เราจะตัดคำสั่ง println! ในฟังก์ชัน main ที่เคยพิมพ์ค่า query และพาธไฟล์ออกไป เพื่อให้โปรแกรมของเราพิมพ์เฉพาะผลลัพธ์การค้นหาล้วนๆ (หากไม่เกิดข้อผิดพลาดใดๆ)

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

เฮ้อ! แม้จะต้องลงแรงปรับเปลี่ยนโค้ดไปพอสมควร แต่เราก็ได้วางรากฐานอันมั่นคงไว้สำหรับก้าวต่อไปในอนาคตเรียบร้อยแล้ว ในตอนนี้การจัดการข้อผิดพลาดทำได้ง่ายขึ้นมาก โค้ดก็มีความเป็นโมดูลาร์อย่างเป็นระเบียบ และนับจากนี้เป็นต้นไป การพัฒนาเกือบทั้งหมดของเราจะทำอยู่ในไฟล์ src/lib.rs

มาใช้ประโยชน์จากโครงสร้างที่แยกเป็นโมดูลนี้ ทำสิ่งที่จะทำได้ยากยิ่งหากใช้โค้ดแบบเดิม แต่กลับทำได้ง่ายดายด้วยโค้ดโครงสร้างใหม่: เราจะมาเขียนชุดทดสอบกัน!