การควบคุมโฟลว์แบบกระชับด้วย if let และ let...else
ไวยากรณ์ if let ช่วยให้เราสามารถรวม if และ let เข้าด้วยกันเพื่อจัดการกับค่าที่ตรงกับแพตเทิร์นเพียงรูปแบบเดียวได้อย่างกระชับ โดยไม่ต้องสนใจกรณีอื่นๆ ที่เหลือ ลองพิจารณาโปรแกรมในลิสติ้ง 6-6 ที่นำค่า Option<u8> ในตัวแปร config_max มาจับคู่กับแพตเทิร์น แต่ต้องการให้โค้ดทำงานเฉพาะในกรณีที่ค่านั้นเป็นวาเรียนต์ Some เท่านั้น
fn main() {
let config_max = Some(3u8);
match config_max {
Some(max) => println!("The maximum is configured to be {max}"),
_ => (),
}
}
หากค่านั้นเป็น Some เราจะพิมพ์ค่าที่บรรจุอยู่ภายในวาเรียนต์ Some ออกมา โดยการผูกค่านั้นเข้ากับตัวแปร max ในแพตเทิร์น และเราไม่ได้ต้องการทำอะไรกับค่า None เลย แต่เพื่อให้ตรงตามข้อกำหนดของนิพจน์ match ที่ต้องครอบคลุมทุกกรณี เราจึงจำใจต้องเพิ่ม _ => () ต่อท้ายหลังจากจัดการวาเรียนต์แรกไปแล้ว ซึ่งกลายเป็นโค้ดส่วนเกินที่ซ้ำซากและน่ารำคาญ (boilerplate code)
แทนที่จะทำเช่นนั้น เราสามารถเขียนให้สั้นและกระชับขึ้นได้ด้วยการใช้ if let โดยโค้ดด้านล่างนี้จะทำงานเหมือนกับคำสั่ง match ในลิสติ้ง 6-6 ทุกประการ:
fn main() {
let config_max = Some(3u8);
if let Some(max) = config_max {
println!("The maximum is configured to be {max}");
}
}
ไวยากรณ์ if let จะรับแพตเทิร์นและนิพจน์โดยคั่นด้วยเครื่องหมายเท่ากับ (=) หลักการทำงานของมันเหมือนกับ match ทุกอย่าง โดยนิพจน์ทางขวาจะถูกส่งเข้าไปเปรียบเทียบ และแพตเทิร์นทางซ้ายจะทำหน้าที่เป็นอาร์มแรกของ match ในตัวอย่างนี้ แพตเทิร์นคือ Some(max) และตัวแปร max จะถูกผูกเข้ากับค่าที่อยู่ภายใน Some จากนั้นเราก็สามารถนำ max มาใช้งานภายในบล็อกของ if let ได้ในลักษณะเดียวกับที่เราใช้ max ในอาร์มของ match โดยโค้ดในบล็อก if let จะทำงานก็ต่อเมื่อค่านั้นตรงกับแพตเทิร์นที่กำหนดไว้เท่านั้น
การใช้ if let ช่วยให้พิมพ์โค้ดน้อยลง ย่อหน้าน้อยลง และลดโค้ด boilerplate ลงไปได้มาก อย่างไรก็ดี สิ่งที่ต้องแลกมาคือเราจะสูญเสียการตรวจสอบความครอบคลุมทุกกรณี (exhaustive checking) ที่ match บังคับใช้เพื่อป้องกันไม่ให้เราลืมจัดการกรณีใดกรณีหนึ่งไป การตัดสินใจเลือกระหว่าง match กับ if let จึงขึ้นอยู่กับสถานการณ์และลักษณะงานของคุณ ว่าความกระชับที่ได้มานั้นคุ้มค่ากับการยอมแลกการตรวจสอบความครบถ้วนของกรณีต่างๆ หรือไม่
พูดอีกอย่างหนึ่งก็คือ เราสามารถมองว่า if let เป็นน้ำตาลทางไวยากรณ์ (syntax sugar) ของคำสั่ง match ที่สั่งให้โค้ดทำงานเมื่อค่าตรงกับแพตเทิร์นหนึ่ง แล้วละเว้นค่าอื่นๆ ทั้งหมดที่เหลือ
นอกจากนี้ เรายังสามารถใส่ else คู่กับ if let ได้ด้วย โดยบล็อกโค้ดในส่วนของ else จะเทียบเท่ากับบล็อกโค้ดในกรณี _ ของนิพจน์ match หากเขียนเทียบเคียงกัน ย้อนกลับไปดูนิยามของ enum Coin ในลิสติ้ง 6-4 ที่วาเรียนต์ Quarter มีการเก็บค่า UsState เอาไว้ข้างใน หากเราต้องการนับจำนวนเหรียญทั้งหมดที่ไม่ใช่เหรียญควอเตอร์ ควบคู่ไปกับการขานชื่อรัฐของเหรียญควอเตอร์ที่พบ เราสามารถเขียนด้วยนิพจน์ match ได้ดังนี้:
#[derive(Debug)]
enum UsState {
Alabama,
Alaska,
// --snip--
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn main() {
let coin = Coin::Penny;
let mut count = 0;
match coin {
Coin::Quarter(state) => println!("State quarter from {state:?}!"),
_ => count += 1,
}
}
หรือเราสามารถเขียนด้วยนิพจน์ if let และ else ได้เช่นกัน ดังนี้:
#[derive(Debug)]
enum UsState {
Alabama,
Alaska,
// --snip--
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn main() {
let coin = Coin::Penny;
let mut count = 0;
if let Coin::Quarter(state) = coin {
println!("State quarter from {state:?}!");
} else {
count += 1;
}
}
อยู่บน “เส้นทางราบรื่น” ด้วย let...else
รูปแบบการเขียนที่พบได้บ่อยมากคือ การทำงานคำนวณบางอย่างเมื่อมีค่าอยู่ และส่งค่าดีฟอลต์ (default value) หรือออกจากฟังก์ชันหากไม่มีค่านั้น ต่อเนื่องจากตัวอย่างเหรียญที่เก็บค่า UsState หากเราอยากจะแสดงข้อความหยอกล้อขึ้นอยู่กับว่ารัฐบนเหรียญควอเตอร์นั้นก่อตั้งมานานแค่ไหน เราอาจจะเพิ่มเมธอดบน UsState เพื่อตรวจสอบอายุของรัฐ ดังนี้:
#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
Alabama,
Alaska,
// --snip--
}
impl UsState {
fn existed_in(&self, year: u16) -> bool {
match self {
UsState::Alabama => year >= 1819,
UsState::Alaska => year >= 1959,
// -- snip --
}
}
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn describe_state_quarter(coin: Coin) -> Option<String> {
if let Coin::Quarter(state) = coin {
if state.existed_in(1900) {
Some(format!("{state:?} is pretty old, for America!"))
} else {
Some(format!("{state:?} is relatively new."))
}
} else {
None
}
}
fn main() {
if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
println!("{desc}");
}
}
จากนั้น เราอาจจะใช้ if let ในการตรวจสอบชนิดของเหรียญ พร้อมทั้งประกาศตัวแปร state ขึ้นมาใช้งานภายในบล็อกเงื่อนไข ดังที่แสดงในลิสติ้ง 6-7
#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
Alabama,
Alaska,
// --snip--
}
impl UsState {
fn existed_in(&self, year: u16) -> bool {
match self {
UsState::Alabama => year >= 1819,
UsState::Alaska => year >= 1959,
// -- snip --
}
}
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn describe_state_quarter(coin: Coin) -> Option<String> {
if let Coin::Quarter(state) = coin {
if state.existed_in(1900) {
Some(format!("{state:?} is pretty old, for America!"))
} else {
Some(format!("{state:?} is relatively new."))
}
} else {
None
}
}
fn main() {
if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
println!("{desc}");
}
}
โค้ดนี้ทำงานได้ตามต้องการก็จริง แต่เป็นการผลักภาระงานทั้งหมดเข้าไปซ้อนอยู่ลึกข้างในบล็อกของคำสั่ง if let และถ้าหากงานที่ต้องทำมีความซับซ้อนมากยิ่งขึ้น ก็อาจทำให้ไล่อ่านและทำความเข้าใจความสัมพันธ์ของกิ่งเงื่อนไขระดับบนได้ยาก เราสามารถใช้ประโยชน์จากข้อเท็จจริงที่ว่านิพจน์จะส่งคืนค่าออกมา เพื่อดึงค่า state ออกมาจาก if let หรือใช้ return ออกจากฟังก์ชันก่อนกำหนด (return early) ได้ ดังที่แสดงในลิสติ้ง 6-8 (ซึ่งสามารถเขียนด้วย match ในลักษณะเดียวกันได้เช่นกัน)
#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
Alabama,
Alaska,
// --snip--
}
impl UsState {
fn existed_in(&self, year: u16) -> bool {
match self {
UsState::Alabama => year >= 1819,
UsState::Alaska => year >= 1959,
// -- snip --
}
}
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn describe_state_quarter(coin: Coin) -> Option<String> {
let state = if let Coin::Quarter(state) = coin {
state
} else {
return None;
};
if state.existed_in(1900) {
Some(format!("{state:?} is pretty old, for America!"))
} else {
Some(format!("{state:?} is relatively new."))
}
}
fn main() {
if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
println!("{desc}");
}
}
อย่างไรก็ตาม การเขียนแบบนี้ก็ยังชวนให้สับสนและติดตามการทำงานได้ยากอยู่ดี! เพราะกิ่งหนึ่งของ if let มีหน้าที่ส่งค่ากลับออกมา ส่วนอีกกิ่งหนึ่งกลับ return ออกจากฟังก์ชันไปเลย
เพื่อให้การเขียนรูปแบบยอดนิยมนี้มีความสวยงามและเป็นธรรมชาติยิ่งขึ้น Rust จึงมีไวยากรณ์ let...else โดย let...else จะรับแพตเทิร์นไว้ทางฝั่งซ้าย และรับนิพจน์ไว้ทางฝั่งขวา คล้ายกับ if let มาก แต่จะไม่มีกิ่ง if มีเพียงแค่กิ่ง else เท่านั้น หากแพตเทิร์นจับคู่สำเร็จ มันจะผูกค่าจากแพตเทิร์นเข้ามาไว้ในขอบเขตภายนอก (outer scope) ทันที แต่ถ้าแพตเทิร์น_ไม่_ตรงกัน โปรแกรมจะวิ่งเข้าไปทำงานในส่วนของ else ซึ่งบังคับว่าจะต้องมีคำสั่ง return ออกจากฟังก์ชัน (หรือคำสั่งอื่นที่ทำให้หลุดจากโฟลว์การทำงาน)
ในลิสติ้ง 6-9 คุณจะเห็นว่าโค้ดจากลิสติ้ง 6-8 จะดูสะอาดตาขึ้นเพียงใดเมื่อเปลี่ยนมาใช้ let...else แทน if let
#[derive(Debug)] // so we can inspect the state in a minute
enum UsState {
Alabama,
Alaska,
// --snip--
}
impl UsState {
fn existed_in(&self, year: u16) -> bool {
match self {
UsState::Alabama => year >= 1819,
UsState::Alaska => year >= 1959,
// -- snip --
}
}
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn describe_state_quarter(coin: Coin) -> Option<String> {
let Coin::Quarter(state) = coin else {
return None;
};
if state.existed_in(1900) {
Some(format!("{state:?} is pretty old, for America!"))
} else {
Some(format!("{state:?} is relatively new."))
}
}
fn main() {
if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
println!("{desc}");
}
}
สังเกตได้ว่า โฟลว์การทำงานหลักของฟังก์ชันจะยังคงอยู่บน “เส้นทางปกติที่ราบรื่น” (happy path) เสมอ โดยไม่ต้องแยกเป็นสองกิ่งที่ควบคุมการทำงานแตกต่างกันอย่างสิ้นเชิงเหมือนกับที่ if let เคยทำ
หากคุณพบเจอสถานการณ์ที่ตรรกะในโปรแกรมดูยืดเยื้อหรือซ้ำซ้อนเกินกว่าจะใช้ match อย่าลืมว่าคุณยังมีเครื่องมืออย่าง if let และ let...else อยู่ในกล่องเครื่องมือของ Rust ให้เลือกใช้งานได้อย่างเหมาะสม
สรุป
จนถึงตอนนี้ เราได้เรียนรู้วิธีการใช้ enum เพื่อสร้างชนิดข้อมูลที่กำหนดขึ้นเอง ซึ่งสามารถเลือกเป็นค่าใดค่าหนึ่งจากกลุ่มของค่าที่แจกแจงไว้ได้อย่างชัดเจน นอกจากนี้ เรายังได้เห็นว่าชนิดข้อมูล Option<T> ในไลบรารีมาตรฐานช่วยให้เราใช้ประโยชน์จากระบบชนิดข้อมูลในการป้องกันข้อผิดพลาดได้อย่างไร และเมื่อค่าของ enum มีข้อมูลบรรจุอยู่ภายใน เราก็สามารถใช้ match หรือ if let ในการดึงข้อมูลเหล่านั้นออกมาใช้งานได้ ขึ้นอยู่กับว่าเราต้องการจัดการกับกรณีต่างๆ มากน้อยเพียงใด
ตอนนี้โปรแกรม Rust ของคุณสามารถถ่ายทอดแนวคิดต่างๆ ในโดเมนของงานได้อย่างสมบูรณ์ผ่าน struct และ enum การสร้างชนิดข้อมูลที่กำหนดขึ้นเองเพื่อใช้ใน API ยังช่วยรับประกันความปลอดภัยของชนิดข้อมูล (type safety) โดยคอมไพเลอร์จะคอยตรวจสอบอย่างเข้มงวดว่า ฟังก์ชันต่างๆ จะได้รับเฉพาะค่าที่มีชนิดข้อมูลตรงตามที่ฟังก์ชันนั้นๆ คาดหวังไว้เท่านั้น
และเพื่อที่เราจะสามารถออกแบบและส่งมอบ API ที่จัดโครงสร้างอย่างเป็นระเบียบ เรียบง่ายต่อการใช้งาน และเปิดเผยให้ผู้ใช้มองเห็นเฉพาะสิ่งที่จำเป็นต้องใช้จริงๆ ในบทถัดไปเราจะมาเรียนรู้เรื่องมอดูล (modules) ของภาษารัสต์กัน