เปลี่ยนเส้นทางข้อผิดพลาดไปยัง standard error
ในตอนนี้ เราส่งเอาต์พุตทั้งหมดของโปรแกรมออกไปยังเทอร์มินัลผ่านทางมาโคร println! เพียงอย่างเดียว แต่ในเทอร์มินัลส่วนใหญ่ เอาต์พุตจะถูกแบ่งออกเป็นสองประเภท ได้แก่: เอาต์พุตมาตรฐาน (standard output หรือ stdout) สำหรับข้อมูลทั่วไป และ ข้อผิดพลาดมาตรฐาน (standard error หรือ stderr) สำหรับข้อความแสดงข้อผิดพลาด การแยกสองสิ่งนี้ออกจากกันช่วยให้ผู้ใช้สามารถเลือกส่งต่อเอาต์พุตจากการทำงานปกติที่สำเร็จไปยังไฟล์ได้ ในขณะที่ยังคงแสดงข้อความแจ้งเตือนข้อผิดพลาดออกทางหน้าจอได้อยู่
เนื่องจากมาโคร println! สามารถพิมพ์ข้อมูลไปยังเอาต์พุตมาตรฐานได้เพียงอย่างเดียว เราจึงต้องใช้วิธีอื่นในการพิมพ์ข้อมูลไปยังข้อผิดพลาดมาตรฐานแทน
การตรวจสอบว่าข้อผิดพลาดถูกเขียนไปที่ใด
ก่อนอื่น เรามาสังเกตดูก่อนว่าเนื้อหาที่ minigrep พิมพ์ออกมาในปัจจุบันถูกเขียนไปยังเอาต์พุตมาตรฐานอย่างไร ซึ่งรวมไปถึงข้อความแสดงข้อผิดพลาดใด ๆ ที่เราต้องการให้ส่งไปยังข้อผิดพลาดมาตรฐานแทนด้วย เราจะทำเช่นนั้นโดยการเปลี่ยนเส้นทาง (redirect) สตรีมของเอาต์พุตมาตรฐานไปยังไฟล์ ควบคู่ไปกับการจงใจทำให้เกิดข้อผิดพลาดขึ้น โดยเราจะไม่เปลี่ยนเส้นทางสตรีมของข้อผิดพลาดมาตรฐาน ดังนั้นข้อมูลใด ๆ ที่ถูกส่งไปยังข้อผิดพลาดมาตรฐานจะยังคงแสดงบนหน้าจอ
โปรแกรมบรรทัดคำสั่ง (command line) ถูกคาดหวังให้ส่งข้อความแสดงข้อผิดพลาดไปยังสตรีมข้อผิดพลาดมาตรฐาน เพื่อให้เรายังคงเห็นข้อความแสดงข้อผิดพลาดบนหน้าจอได้แม้ว่าจะเปลี่ยนเส้นทางสตรีมเอาต์พุตมาตรฐานไปยังไฟล์ แต่โปรแกรมของเราในตอนนี้ยังทำงานได้ไม่ดีเท่าที่ควร: เรากำลังจะได้เห็นกันว่ามันกลับบันทึกข้อความแสดงข้อผิดพลาดลงไปในไฟล์แทน!
เพื่อแสดงให้เห็นพฤติกรรมนี้ เราจะรันโปรแกรมด้วย > และพาธไฟล์ output.txt ที่เราต้องการเปลี่ยนเส้นทางสตรีมเอาต์พุตมาตรฐานไปลง โดยเราจะไม่ส่งอาร์กิวเมนต์ (argument) ใด ๆ เข้าไป ซึ่งควรทำให้เกิดข้อผิดพลาด:
$ cargo run > output.txt
ไวยากรณ์ > สั่งให้เชลล์เขียนเนื้อหาจากเอาต์พุตมาตรฐานไปยัง output.txt แทนที่จะแสดงออกทางหน้าจอ เมื่อรันคำสั่งแล้วเราไม่เห็นข้อความแสดงข้อผิดพลาดที่คาดว่าจะถูกพิมพ์บนหน้าจอ ซึ่งแสดงว่ามันต้องถูกเขียนลงไปในไฟล์ นี่คือสิ่งที่อยู่ใน output.txt:
Problem parsing arguments: not enough arguments
ใช่แล้ว ข้อความแสดงข้อผิดพลาดของเราถูกพิมพ์ไปยังเอาต์พุตมาตรฐาน การพิมพ์ข้อความแสดงข้อผิดพลาดแบบนี้ไปยังข้อผิดพลาดมาตรฐานมีประโยชน์กว่ามาก เพื่อให้มีเฉพาะข้อมูลจากการรันที่สำเร็จเท่านั้นที่ถูกบันทึกลงในไฟล์ เรามาแก้ไขเรื่องนี้กัน
การพิมพ์ข้อผิดพลาดไปยังข้อผิดพลาดมาตรฐาน
เราจะใช้โค้ดในลิสติ้ง 12-24 เพื่อเปลี่ยนวิธีพิมพ์ข้อความแสดงข้อผิดพลาด เนื่องจากการรีแฟกเตอร์ (refactor) ที่เราทำไปก่อนหน้าในบทนี้ โค้ดทั้งหมดที่พิมพ์ข้อความแสดงข้อผิดพลาดจึงรวมอยู่ในฟังก์ชันเดียวคือ main ไลบรารีมาตรฐานมีมาโคร eprintln! ที่พิมพ์ไปยังสตรีมข้อผิดพลาดมาตรฐาน ดังนั้นมาเปลี่ยนสองจุดที่เราเรียก println! เพื่อพิมพ์ข้อผิดพลาดให้หันมาใช้ eprintln! แทนกัน
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);
});
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(())
}
ตอนนี้มาลองรันโปรแกรมอีกครั้งในแบบเดียวกัน โดยไม่ใส่อาร์กิวเมนต์และเปลี่ยนเส้นทางเอาต์พุตมาตรฐานด้วย >:
$ cargo run > output.txt
Problem parsing arguments: not enough arguments
ตอนนี้เราจะเห็นข้อผิดพลาดปรากฏบนหน้าจอ และ output.txt ไม่บรรจุอะไรเลย ซึ่งเป็นพฤติกรรมที่เราคาดหวังจากโปรแกรมบรรทัดคำสั่ง
มาลองรันโปรแกรมอีกครั้งด้วยอาร์กิวเมนต์ที่ไม่ทำให้เกิดข้อผิดพลาด แต่ยังคงเปลี่ยนเส้นทางเอาต์พุตมาตรฐานไปยังไฟล์ ดังนี้:
$ cargo run -- to poem.txt > output.txt
เราจะไม่เห็นเอาต์พุตใด ๆ ไปยังเทอร์มินัล และ output.txt จะบรรจุผลลัพธ์ของเรา:
ชื่อไฟล์: output.txt
Are you nobody, too?
How dreary to be somebody!
สิ่งนี้แสดงให้เห็นว่าตอนนี้เราใช้เอาต์พุตมาตรฐานสำหรับผลลัพธ์ที่สำเร็จ และใช้ข้อผิดพลาดมาตรฐานสำหรับเอาต์พุตข้อผิดพลาดอย่างเหมาะสมแล้ว
สรุป
บทนี้ได้ทบทวนแนวคิดสำคัญหลาย ๆ ประการที่คุณได้เรียนรู้มาจนถึงตอนนี้ และครอบคลุมวิธีจัดการงาน I/O พื้นฐานใน Rust ด้วยการใช้อาร์กิวเมนต์บรรทัดคำสั่ง ไฟล์ ตัวแปรสภาพแวดล้อม (environment variable) และมาโคร eprintln! สำหรับพิมพ์ข้อผิดพลาด ตอนนี้คุณพร้อมแล้วที่จะเขียนแอปพลิเคชันบรรทัดคำสั่ง เมื่อรวมกับแนวคิดในบทก่อน ๆ โค้ดของคุณจะถูกจัดระเบียบอย่างดี จัดเก็บข้อมูลอย่างมีประสิทธิภาพในโครงสร้างข้อมูลที่เหมาะสม จัดการข้อผิดพลาดได้อย่างรัดกุม และผ่านการทดสอบมาเป็นอย่างดี
ต่อไป เราจะสำรวจฟีเจอร์ของ Rust บางอย่างที่ได้รับอิทธิพลจากภาษาเชิงฟังก์ชัน: โคลเชอร์ (closure) และอิเทอเรเตอร์ (iterator)