จะ panic! หรือไม่ panic!
แล้วเราจะตัดสินใจอย่างไรว่าเมื่อใดควรเรียก panic! และเมื่อใดควรส่งคืนค่า Result? เมื่อโค้ดเกิดการแพนิก (panic) ขึ้น จะไม่มีทางกู้คืนสถานะกลับมาได้อีก คุณอาจจะเลือกเรียกใช้ panic! กับทุกสถานการณ์ที่เกิดข้อผิดพลาด ไม่ว่าจะมีหนทางกู้คืนได้หรือไม่ก็ตาม แต่การทำเช่นนั้นเท่ากับว่าคุณกำลังตัดสินใจแทนโค้ดต้นทางที่เรียกใช้ว่าสถานการณ์นั้นๆ เป็นสิ่งที่ไม่สามารถกู้คืนได้ ทว่าเมื่อคุณเลือกที่จะส่งคืนค่าเป็น Result คุณกำลังมอบทางเลือกให้แก่โค้ดต้นทางที่เรียกใช้ ซึ่งโค้ดต้นทางอาจเลือกที่จะพยายามกู้คืนด้วยวิธีที่เหมาะสมกับบริบทของมัน หรืออาจตัดสินว่าค่า Err ในกรณีนี้ไม่สามารถกู้คืนได้ แล้วจึงเป็นฝ่ายเรียก panic! เพื่อเปลี่ยนข้อผิดพลาดที่กู้คืนได้ (recoverable error) ของคุณให้กลายเป็นข้อผิดพลาดที่กู้คืนไม่ได้ (unrecoverable error) เสียเอง ดังนั้น การส่งคืนค่า Result จึงเป็นตัวเลือกเริ่มต้นที่ดีเสมอเมื่อคุณนิยามฟังก์ชันที่มีโอกาสทำงานล้มเหลว
อย่างไรก็ดี ในบางสถานการณ์ เช่น โค้ดตัวอย่าง, โค้ดต้นแบบ (prototype) และการเขียนเทสต์ การเขียนโค้ดให้เกิด panic มักจะเหมาะสมกว่าการส่งคืน Result มาดูกันว่าทำไมจึงเป็นเช่นนั้น จากนั้นเราจะพูดคุยถึงสถานการณ์ที่คอมไพเลอร์ไม่สามารถบอกได้ว่าข้อผิดพลาดจะไม่มีทางเกิดขึ้น แต่คุณในฐานะมนุษย์สามารถล่วงรู้ได้ และเราจะปิดท้ายบทนี้ด้วยแนวทางปฏิบัติทั่วไปในการตัดสินใจว่าจะสั่ง panic ในโค้ดไลบรารีหรือไม่
ตัวอย่าง โค้ดต้นแบบ และการทดสอบ
เมื่อคุณเขียนโค้ดตัวอย่างเพื่ออธิบายแนวคิดอะไรบางอย่าง การใส่โค้ดจัดการข้อผิดพลาดแบบเต็มรูปแบบเข้าไปด้วยอาจทำให้ตัวอย่างนั้นดูซับซ้อนและเข้าใจยากขึ้น ในโค้ดตัวอย่างจึงเป็นที่เข้าใจกันดีว่า การเรียกเมธอดอย่าง unwrap ที่อาจทำให้เกิด panic นั้น มีเจตนาเพื่อเป็นตัวแทนชั่วคราว (placeholder) สำหรับจุดที่คุณต้องการให้แอปพลิเคชันจัดการกับข้อผิดพลาด ซึ่งอาจแตกต่างกันไปตามบริบทของโค้ดส่วนอื่นๆ
ในทำนองเดียวกัน เมธอด unwrap และ expect นั้นสะดวกและมีประโยชน์อย่างยิ่งในขั้นตอนการทำต้นแบบ (prototyping) ก่อนที่คุณจะพร้อมตัดสินใจว่าจะจัดการกับข้อผิดพลาดแต่ละจุดอย่างไร โดยพวกมันจะทำหน้าที่เป็นจุดสังเกตที่ชัดเจนในโค้ด เพื่อให้คุณกลับมาปรับปรุงโค้ดให้รัดกุมยิ่งขึ้นในภายหลัง
และหากการเรียกเมธอดใดทำงานล้มเหลวในระหว่างการรันเทสต์ คุณย่อมต้องการให้เทสต์เคสนั้นล้มเหลวทันที แม้ว่าเมธอดดังกล่าวจะไม่ใช่ฟังก์ชันการทำงานหลักที่กำลังถูกทดสอบอยู่ก็ตาม และเนื่องจากกลไกการแพนิกคือวิธีที่ Rust ใช้ระบุว่าเทสต์เคสนั้นไม่ผ่าน (failure) การเรียกใช้ unwrap หรือ expect จึงเป็นสิ่งที่เหมาะสมและควรทำอย่างยิ่งในการเขียนเทสต์
เมื่อคุณมีข้อมูลมากกว่าคอมไพเลอร์
นอกจากนี้ การเรียกใช้ expect ยังเหมาะสมอย่างยิ่งเมื่อคุณมีตรรกะอื่นที่รับประกันได้แน่นอนว่าค่า Result จะเป็น Ok เสมอ แต่ตรรกะนั้นอยู่นอกเหนือสิ่งที่คอมไพเลอร์จะเข้าใจได้ คุณจึงยังคงต้องรับมือกับค่า Result อยู่: ไม่ว่าการทำงานที่คุณเรียกใช้จะมีโอกาสล้มเหลวได้ในกรณีทั่วไป แต่ในสถานการณ์เฉพาะของคุณนั้นในทางตรรกะแล้วย่อมไม่มีทางล้มเหลวได้อย่างแน่นอน หากคุณตรวจสอบโค้ดอย่างถี่ถ้วนแล้วมั่นใจว่าจะไม่มีทางได้วาเรียนต์ Err เด็ดขาด การเรียกใช้ expect พร้อมกับบันทึกเหตุผลลงในข้อความแจ้งเตือนว่าทำไมจึงไม่มีทางเกิด Err ขึ้นได้ จึงเป็นแนวทางปฏิบัติที่ยอมรับได้และดีอย่างยิ่ง ดังตัวอย่างนี้:
fn main() {
use std::net::IpAddr;
let home: IpAddr = "127.0.0.1"
.parse()
.expect("Hardcoded IP address should be valid");
}
เรากำลังสร้างอินสแตนซ์ของ IpAddr โดยการพาร์สสตริงที่ฮาร์ดโค้ดไว้ เรามองเห็นได้ชัดเจนว่า 127.0.0.1 เป็นไอพีแอดเดรสที่ถูกต้องแน่นอน จึงยอมรับได้ที่จะใช้ expect ตรงจุดนี้ ทว่าการฮาร์ดโค้ดสตริงที่ถูกต้องไม่ได้เปลี่ยนประเภทข้อมูลส่งกลับของเมธอด parse: เรายังคงได้ค่า Result กลับมา และคอมไพเลอร์ก็ยังคงบังคับให้เราจัดการกับ Result นั้นเสมือนว่าอาจเกิดวาเรียนต์ Err ขึ้นได้ เพราะคอมไพเลอร์ไม่ได้ฉลาดพอที่จะรู้ว่าสตริงนี้เป็นไอพีแอดเดรสที่ถูกต้องเสมอ แต่หากสตริงไอพีแอดเดรสนั้นรับมาจากผู้ใช้แทนที่จะฮาร์ดโค้ดไว้ในโปรแกรม ซึ่งย่อม มี โอกาสเกิดข้อผิดพลาดขึ้นได้แน่นอน เราก็ควรจัดการกับ Result นั้นด้วยวิธีที่รัดกุมกว่านี้ การระบุสมมติฐานไว้ในข้อความของ expect ว่าไอพีนี้มาจากการฮาร์ดโค้ด จะช่วยเตือนสติเราให้เปลี่ยนไปใช้โค้ดจัดการข้อผิดพลาดที่เหมาะสมกว่า หากในอนาคตเราต้องเปลี่ยนไปรับไอพีแอดเดรสจากแหล่งอื่นแทน
แนวทางสำหรับการจัดการข้อผิดพลาด
ขอแนะนำให้โค้ดของคุณเกิด panic ขึ้นเมื่อมีความเป็นไปได้ว่าโปรแกรมอาจตกอยู่ในสภาวะที่ไม่พึงประสงค์ (bad state) ในบริบทนี้ สภาวะที่ไม่พึงประสงค์ หมายถึง การที่สมมติฐาน, ข้อรับประกัน, ข้อตกลง (contract) หรือความคงเส้นคงวา (invariant) บางประการถูกทำลายลง เช่น มีการส่งค่าที่ไม่ถูกต้อง, ค่าที่ขัดแย้งกันเอง หรือค่าที่ขาดหายเข้ามายังโค้ดของคุณ ร่วมกับเงื่อนไขข้อใดข้อหนึ่งหรือหลายข้อดังต่อไปนี้:
- สภาวะที่ไม่พึงประสงค์นั้นเป็นสิ่งที่ไม่ควรเกิดขึ้นอย่างสิ้นเชิง (unexpected) ซึ่งต่างจากสิ่งที่อาจเกิดขึ้นได้เป็นธรรมดา เช่น การที่ผู้ใช้กรอกข้อมูลผิดรูปแบบ
- โค้ดที่ทำงานต่อหลังจากจุดนี้จำเป็นต้องเชื่อมั่นได้ว่าโปรแกรมไม่ได้อยู่ในสภาวะที่ไม่พึงประสงค์ดังกล่าว แทนที่จะต้องคอยเขียนโค้ดตรวจสอบปัญหาซ้ำซากในทุกๆ ขั้นตอน
- ไม่มีหนทางที่ดีในการเข้ารหัสข้อมูลนี้ไว้ในระบบประเภทข้อมูลที่คุณใช้งาน (เราจะยกตัวอย่างเรื่องนี้ให้เห็นชัดเจนในหัวข้อ “การเข้ารหัสสถานะและพฤติกรรมเป็นชนิดข้อมูล” ในบทที่ 18)
หากมีคนเรียกใช้โค้ดของคุณโดยส่งค่าที่ไม่สมเหตุสมผลเข้ามา วิธีที่ดีที่สุดคือการส่งคืนข้อผิดพลาดกลับไปถ้าทำได้ เพื่อให้ผู้เรียกใช้ไลบรารีตัดสินใจเองว่าจะทำอย่างไรในกรณีนั้น อย่างไรก็ตาม หากการทำงานต่อไปอาจก่อให้เกิดความไม่ปลอดภัยหรือความเสียหาย ทางเลือกที่ดีที่สุดอาจเป็นการเรียกใช้ panic! เพื่อแจ้งเตือนผู้ใช้งานไลบรารีให้ทราบถึงบั๊กในโค้ดของพวกเขา เพื่อที่พวกเขาจะได้แก้ไขให้ถูกต้องในระหว่างการพัฒนา ในทำนองเดียวกัน การเรียก panic! มักจะเหมาะสมเมื่อคุณเรียกใช้โค้ดภายนอกที่อยู่นอกเหนือการควบคุมของคุณ แล้วโค้ดนั้นส่งสถานะที่ไม่ถูกต้องกลับมาจนคุณไม่มีทางแก้ไขอะไรได้
แต่เมื่อใดที่ความล้มเหลวเป็นสิ่งที่คาดการณ์ได้อยู่แล้ว การส่งคืนค่า Result ย่อมเหมาะสมกว่าการสั่ง panic! เสมอ ตัวอย่างเช่น โมดูลพาร์เซอร์ที่ได้รับข้อมูลผิดรูปแบบ หรือคำขอ HTTP ที่ส่งสถานะแจ้งว่าคุณเรียกใช้งานเกินโควตา (rate limit) ในสถานการณ์เหล่านี้ การส่งคืน Result เป็นการส่งสัญญาณว่าความล้มเหลวเป็นสิ่งที่มีโอกาสเกิดขึ้นได้ และโค้ดต้นทางที่เรียกใช้จะต้องเตรียมการรับมือเอาไว้
เมื่อโค้ดของคุณต้องทำงานที่มีความเสี่ยงต่อความปลอดภัยหากถูกเรียกใช้ด้วยค่าที่ไม่ถูกต้อง โค้ดของคุณควรตรวจสอบความถูกต้องของค่านั้นก่อน และสั่ง panic หากพบว่าค่านั้นไม่ถูกต้อง ทั้งนี้เพื่อความปลอดภัยเป็นหลัก: เพราะการฝืนประมวลผลข้อมูลที่ไม่ถูกต้องต่อไปอาจเปิดช่องโหว่ด้านความปลอดภัยร้ายแรงได้ นี่คือเหตุผลสำคัญที่ไลบรารีมาตรฐานจะเรียก panic! ทันทีหากคุณพยายามเข้าถึงหน่วยความจำเกินขอบเขต เพราะการเข้าถึงหน่วยความจำที่ไม่ได้เป็นของโครงสร้างข้อมูลนั้นถือเป็นปัญหาความปลอดภัยที่พบบ่อย นอกจากนี้ ฟังก์ชันมักจะมี ข้อตกลง (contracts): พฤติกรรมของมันจะได้รับการรับประกันก็ต่อเมื่ออินพุตตรงตามเงื่อนไขที่กำหนดเท่านั้น การสั่ง panic เมื่อข้อตกลงถูกละเมิดจึงเป็นสิ่งที่สมเหตุสมผล เพราะการละเมิดข้อตกลงบ่งชี้ถึงบั๊กของฝั่งผู้เรียกใช้เสมอ และไม่ใช่ข้อผิดพลาดประเภทที่โค้ดต้นทางควรจะดักจับไปทำงานต่อ เพราะในความเป็นจริง โค้ดต้นทางไม่มีทางกู้คืนสถานะได้อย่างสมเหตุสมผลเลย แต่เป็นตัว โปรแกรมเมอร์ เองที่ต้องไปแก้โค้ดให้ถูกต้อง โดยข้อตกลงของฟังก์ชัน (โดยเฉพาะอย่างยิ่งกรณีที่การละเมิดจะทำให้เกิด panic) ควรได้รับการอธิบายไว้อย่างชัดเจนในเอกสาร API ของฟังก์ชันนั้น
อย่างไรก็ตาม การใส่โค้ดตรวจเช็กข้อผิดพลาดจำนวนมหาศาลไว้ในทุกฟังก์ชันย่อมทำให้โค้ดยืดยาวและน่ารำคาญ โชคดีที่คุณสามารถใช้ระบบประเภทข้อมูลของ Rust (และการตรวจสอบประเภทข้อมูลโดยคอมไพเลอร์) มาช่วยทำงานตรวจสอบเหล่านี้แทนคุณได้ หากฟังก์ชันของคุณกำหนดพารามิเตอร์เป็นประเภทข้อมูลที่เฉพาะเจาะจง คุณก็สามารถเขียนตรรกะของโค้ดต่อไปได้อย่างสบายใจโดยรู้ว่าคอมไพเลอร์ได้รับประกันความถูกต้องของค่านั้นไว้แล้ว ตัวอย่างเช่น หากคุณกำหนดประเภทข้อมูลแบบตรงๆ แทนที่จะเป็น Option โปรแกรมของคุณก็คาดหวังว่าจะได้รับ ข้อมูลบางอย่าง เสมอโดยไม่มีทาง ว่างเปล่า โค้ดของคุณจึงไม่ต้องคอยจัดการสองกรณีระหว่างวาเรียนต์ Some และ None: แต่จะมีเพียงกรณีเดียวที่มั่นใจได้ว่ามีค่าแน่นอน โค้ดที่พยายามส่งค่าว่างเปล่ามายังฟังก์ชันจะไม่สามารถคอมไพล์ผ่านได้เลย ฟังก์ชันของคุณจึงไม่ต้องเสียเวลาตรวจสอบกรณีนั้นในตอนรันไทม์ หรืออีกตัวอย่างหนึ่งคือการใช้ประเภทจำนวนเต็มไม่มีเครื่องหมายอย่าง u32 ซึ่งจะช่วยรับประกันได้ทันทีว่าพารามิเตอร์นั้นจะไม่มีทางเป็นค่าติดลบอย่างแน่นอน
ชนิดข้อมูลที่กำหนดเองสำหรับการตรวจสอบความถูกต้อง
มาต่อยอดแนวคิดเรื่องการใช้ระบบประเภทข้อมูลของ Rust เพื่อรับประกันความถูกต้องของค่าให้ลึกซึ้งยิ่งขึ้น โดยการสร้างประเภทข้อมูลที่กำหนดขึ้นเอง (custom type) เพื่อใช้ในการตรวจสอบความถูกต้อง ย้อนกลับไปดูเกมทายตัวเลขในบทที่ 2 ซึ่งโค้ดของเราขอให้ผู้ใช้ทายตัวเลขระหว่าง 1 ถึง 100 ในตอนนั้นเราไม่ได้ตรวจสอบเลยว่าตัวเลขที่ผู้ใช้ทายเข้ามานั้นอยู่ในช่วง 1 ถึง 100 หรือไม่ ก่อนที่จะนำไปเปรียบเทียบกับตัวเลขลับ แต่เราตรวจสอบเพียงแค่ว่าค่าที่ป้อนเข้ามาเป็นจำนวนบวกเท่านั้น ซึ่งในกรณีนั้น ผลลัพธ์ไม่ได้เลวร้ายอะไรมากนัก: ข้อความแจ้งเตือน “สูงเกินไป” หรือ “ต่ำเกินไป” ของเราก็ยังคงทำงานได้อย่างถูกต้อง แต่จะดีกว่ามากหากเราปรับปรุงให้โปรแกรมสามารถแนะนำผู้ใช้ให้ทายตัวเลขที่ถูกต้อง และมีพฤติกรรมการตอบสนองที่แตกต่างกันอย่างชัดเจนเมื่อผู้ใช้ทายตัวเลขที่อยู่นอกช่วง เทียบกับกรณีที่ผู้ใช้พิมพ์ตัวอักษรเข้ามา
วิธีหนึ่งในการทำเช่นนี้คือ การพาร์สคำทายให้เป็น i32 แทนที่จะเป็นแค่ u32 เพื่อเปิดรับตัวเลขที่อาจติดลบได้ แล้วจึงเพิ่มการตรวจสอบว่าตัวเลขดังกล่าวอยู่ในช่วงที่กำหนดหรือไม่ ดังนี้:
use std::cmp::Ordering;
use std::io;
use rand::prelude::*;
fn main() {
println!("Guess the number!");
let secret_number = rand::rng().random_range(1..=100);
loop {
// --snip--
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: i32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
if guess < 1 || guess > 100 {
println!("The secret number will be between 1 and 100.");
continue;
}
match guess.cmp(&secret_number) {
// --snip--
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
นิพจน์ if จะตรวจสอบว่าค่าของเราอยู่นอกช่วงหรือไม่ หากนอกช่วงก็จะแจ้งเตือนปัญหาให้ผู้ใช้ทราบ แล้วเรียกใช้ continue เพื่อเริ่มต้นลูปรอบถัดไปและขอให้ทายตัวเลขใหม่ และหลังจากผ่านนิพจน์ if ไปได้ เราก็สามารถทำการเปรียบเทียบระหว่าง guess กับตัวเลขลับได้อย่างมั่นใจว่า guess จะมีค่าอยู่ระหว่าง 1 ถึง 100 แน่นอน
อย่างไรก็ตาม นี่ไม่ใช่วิธีแก้ปัญหาในอุดมคติ: หากการจำกัดให้โปรแกรมทำงานเฉพาะกับค่าระหว่าง 1 ถึง 100 เป็นเรื่องสำคัญยิ่งยวด และมีหลายๆ ฟังก์ชันที่ต้องปฏิบัติตามข้อกำหนดนี้ การที่ต้องมาคอยเขียนโค้ดตรวจสอบแบบนี้ซ้ำๆ ในทุกฟังก์ชันย่อมเป็นเรื่องที่น่าเบื่อหน่าย (และอาจส่งผลกระทบต่อประสิทธิภาพการทำงานด้วย)
แทนที่จะทำเช่นนั้น เราสามารถสร้างประเภทข้อมูลใหม่ขึ้นมาในมอดูลแยกต่างหาก แล้วรวมตรรกะการตรวจสอบความถูกต้องไว้ในฟังก์ชันสร้างอินสแตนซ์ของประเภทนั้น แทนที่จะต้องเขียนโค้ดตรวจสอบซ้ำไปซ้ำมาในทุกที่ ด้วยวิธีนี้ ฟังก์ชันต่างๆ จะสามารถนำประเภทข้อมูลใหม่นี้ไปใช้ในลายเซ็นของฟังก์ชันได้อย่างปลอดภัย และสามารถนำค่าที่ได้รับไปใช้งานต่อได้อย่างมั่นใจ ลิสติ้ง 9-13 แสดงวิธีหนึ่งในการนิยามประเภท Guess ซึ่งจะสร้างอินสแตนซ์ของ Guess ได้ก็ต่อเมื่อฟังก์ชัน new ได้รับค่าที่อยู่ระหว่าง 1 ถึง 100 เท่านั้น
#![allow(unused)]
fn main() {
pub struct Guess {
value: i32,
}
impl Guess {
pub fn new(value: i32) -> Guess {
if value < 1 || value > 100 {
panic!("Guess value must be between 1 and 100, got {value}.");
}
Guess { value }
}
pub fn value(&self) -> i32 {
self.value
}
}
}
โปรดทราบว่าโค้ดใน src/guessing_game.rs นี้ขึ้นอยู่กับการประกาศมอดูล mod guessing_game; ในไฟล์ src/lib.rs ซึ่งเราไม่ได้แสดงไว้ในที่นี้ โดยภายในไฟล์มอดูลใหม่นี้ เราได้นิยาม struct ชื่อ Guess ที่มีฟิลด์ชื่อ value เก็บค่าประเภท i32 ซึ่งเป็นจุดที่จะใช้จัดเก็บตัวเลข
จากนั้น เราได้อิมพลีเมนต์ฟังก์ชันที่เชื่อมโยงกับชนิดข้อมูล (associated function) ชื่อ new บน Guess เพื่อทำหน้าที่สร้างอินสแตนซ์ของ Guess โดยฟังก์ชัน new ถูกนิยามให้รับพารามิเตอร์หนึ่งตัวชื่อ value ประเภท i32 และส่งคืนค่าเป็น Guess โค้ดภายในฟังก์ชัน new จะทดสอบค่า value เพื่อให้แน่ใจว่าอยู่ระหว่าง 1 ถึง 100 หาก value ไม่ผ่านเงื่อนไขนี้ เราจะสั่งเรียก panic! เพื่อแจ้งเตือนโปรแกรมเมอร์ที่เขียนโค้ดเรียกใช้ฟังก์ชันว่าพวกเขามีบั๊กที่ต้องแก้ไข เพราะการสร้าง Guess ด้วย value ที่อยู่นอกช่วงนี้ถือเป็นการละเมิดข้อตกลงที่ Guess::new กำหนดไว้ โดยเงื่อนไขที่อาจทำให้ Guess::new เกิด panic นั้นควรระบุไว้ในเอกสาร API สาธารณะของฟังก์ชัน ซึ่งเราจะพูดถึงธรรมเนียมการเขียนเอกสารแจ้งเตือนโอกาสที่จะเกิด panic! ในเอกสาร API ในบทที่ 14 และหากค่า value ผ่านเงื่อนไขการทดสอบ เราจะสร้างอินสแตนซ์ Guess ใหม่โดยกำหนดฟิลด์ value ให้มีค่าตามพารามิเตอร์ value แล้วส่งคืน Guess นั้นออกมา
ลำดับถัดไป เราได้อิมพลีเมนต์เมธอดชื่อ value ซึ่งยืม self โดยไม่มีพารามิเตอร์อื่น และส่งคืนค่าเป็น i32 เมธอดลักษณะนี้บางครั้งเรียกว่า เก็ตเตอร์ (getter) เพราะมีเป้าหมายเพื่อดึงข้อมูลจากฟิลด์ภายในส่งคืนออกไป โดยเมธอดสาธารณะนี้จำเป็นต้องมีเนื่องจากฟิลด์ value ของ struct Guess ถูกกำหนดให้เป็นแบบส่วนตัว (private) การทำให้ฟิลด์ value เป็น private นั้นมีความสำคัญอย่างยิ่ง เพื่อป้องกันไม่ให้โค้ดภายนอกที่นำ struct Guess ไปใช้สามารถแก้ไขค่า value ได้โดยตรง นั่นทำให้โค้ดภายนอกมอดูล guessing_game จำเป็นต้อง เรียกผ่านฟังก์ชัน Guess::new เพื่อสร้างอินสแตนซ์ของ Guess เสมอ ซึ่งช่วยรับประกันได้ว่า Guess จะไม่มีทางมีค่า value ที่เล็ดลอดการตรวจสอบเงื่อนไขในฟังก์ชัน Guess::new ไปได้เลย
ดังนั้น ฟังก์ชันอื่นๆ ที่ต้องการรับพารามิเตอร์หรือส่งคืนเฉพาะตัวเลขระหว่าง 1 ถึง 100 ก็สามารถประกาศในลายเซ็นฟังก์ชันได้ทันทีว่ารับหรือคืนค่าประเภท Guess แทนที่จะเป็น i32 และไม่จำเป็นต้องเขียนโค้ดตรวจสอบเงื่อนไขเพิ่มเติมในเนื้อหาของฟังก์ชันอีกต่อไป
สรุป
ฟีเจอร์การจัดการข้อผิดพลาดของ Rust ได้รับการออกแบบมาเพื่อช่วยให้คุณเขียนโค้ดที่มีความทนทานและเสถียร (robust) ยิ่งขึ้น โดยแมโคร panic! จะทำหน้าที่ส่งสัญญาณเตือนว่าโปรแกรมกำลังตกอยู่ในสภาวะที่ไม่สามารถจัดการต่อไปได้ และช่วยสั่งให้โปรเซสหยุดทำงานแทนที่จะฝืนประมวลผลต่อด้วยค่าที่ไม่ถูกต้อง ส่วน enum Result อาศัยระบบประเภทข้อมูลอันทรงพลังของ Rust เพื่อบ่งบอกว่าการทำงานอาจเกิดความล้มเหลวในลักษณะที่โค้ดของคุณสามารถกู้คืนได้ คุณสามารถใช้ Result เพื่อแจ้งให้โค้ดต้นทางที่เรียกใช้เตรียมพร้อมรับมือกับผลลัพธ์ทั้งกรณีที่สำเร็จและล้มเหลว การเลือกใช้ panic! และ Result อย่างเหมาะสมตามสถานการณ์จะช่วยให้โค้ดของคุณมีความน่าเชื่อถือและพร้อมรับมือกับปัญหาต่างๆ ที่อาจเกิดขึ้นได้อย่างมั่นใจ
หลังจากที่คุณได้เห็นตัวอย่างอันทรงพลังที่ไลบรารีมาตรฐานนำเจเนอริกมาใช้ร่วมกับ enum Option และ Result ไปแล้ว ในบทถัดไปเราจะมาเจาะลึกกันว่า เจเนอริกทำงานอย่างไร และคุณจะสามารถนำมันมาประยุกต์ใช้ในโค้ดของคุณได้อย่างไร