ทุกจุดที่ใช้แพตเทิร์นได้
แพตเทิร์นปรากฏอยู่ในหลายจุดทั่วทั้งภาษา Rust และความจริงแล้วคุณอาจได้ใช้งานมันมาบ่อยครั้งโดยไม่รู้ตัว! หัวข้อนี้จะพาไปสำรวจทุกตำแหน่งในโค้ดที่สามารถนำแพตเทิร์นไปใช้งานได้
อาร์มของ match
ดังที่เราได้พูดคุยกันในบทที่ 6 เราใช้แพตเทิร์นในอาร์ม (arm) ของนิพจน์ match โดยตามรูปแบบโครงสร้างแล้ว นิพจน์ match ถูกนิยามขึ้นจากคีย์เวิร์ด match, ค่าที่ต้องการนำมาเปรียบเทียบจับคู่ และอาร์มของ match อย่างน้อยหนึ่งอาร์มขึ้นไป ซึ่งแต่ละอาร์มจะประกอบด้วยแพตเทิร์นและนิพจน์ที่จะถูกประมวลผล หากค่านั้นจับคู่กับแพตเทิร์นของอาร์มดังกล่าวได้สำเร็จ ดังนี้:
match VALUE {
PATTERN => EXPRESSION,
PATTERN => EXPRESSION,
PATTERN => EXPRESSION,
}
ตัวอย่างเช่น นี่คือนิพจน์ match จากลิสติ้ง 6-5 ที่จับคู่กับค่า Option<i32> ในตัวแปร x:
match x {
None => None,
Some(i) => Some(i + 1),
}
แพตเทิร์นในนิพจน์ match นี้คือ None และ Some(i) ซึ่งอยู่ทางด้านซ้ายของลูกศรในแต่ละบรรทัด
ข้อกำหนดสำคัญประการหนึ่งของนิพจน์ match คือ มันต้องครอบคลุมครบถ้วนทุกกรณี (exhaustive) ซึ่งหมายความว่า ทุกความเป็นไปได้ของค่าในนิพจน์ match จะต้องถูกนำมาพิจารณาและจัดการทั้งหมด วิธีหนึ่งที่จะช่วยรับประกันว่าคุณได้ครอบคลุมครบทุกกรณีแล้ว คือการมีแพตเทิร์นแบบครอบคลุมทั้งหมด (catch-all pattern) ไว้ในอาร์มสุดท้าย ตัวอย่างเช่น การใช้ชื่อตัวแปรที่สามารถจับคู่กับค่าใด ๆ ก็ได้ ซึ่งไม่มีวันจับคู่ล้มเหลว จึงช่วยเก็บตกทุกกรณีที่เหลืออยู่ได้ทั้งหมด
โดยเฉพาะแพตเทิร์น _ นั้นจะสามารถจับคู่ได้กับทุกค่า แต่จะไม่ผูกค่านั้นเข้ากับตัวแปรใด ๆ จึงมักนิยมนำมาใช้ในอาร์มสุดท้ายของ match ตัวอย่างเช่น แพตเทิร์น _ จะมีประโยชน์อย่างยิ่งเมื่อคุณต้องการเพิกเฉยต่อค่าอื่น ๆ ทั้งหมดที่ไม่ได้ระบุไว้ เราจะอธิบายรายละเอียดของแพตเทิร์น _ เพิ่มเติมในหัวข้อ “การเพิกเฉยต่อค่าในแพตเทิร์น” ในช่วงท้ายของบทนี้
สเตตเมนต์ let
ก่อนจะถึงบทนี้ เราได้พูดถึงการใช้แพตเทิร์นกับ match และ if let เป็นหลัก แต่ความจริงแล้ว เรายังใช้แพตเทิร์นในจุดอื่น ๆ อีกด้วย รวมถึงในสเตตเมนต์ (statement) let ตัวอย่างเช่น ลองพิจารณาการกำหนดค่าตัวแปรแบบเรียบง่ายด้วย let ต่อไปนี้:
#![allow(unused)]
fn main() {
let x = 5;
}
ทุกครั้งที่คุณใช้สเตตเมนต์ let เช่นนี้ คุณกำลังใช้งานแพตเทิร์นอยู่ แม้คุณอาจจะไม่ทันสังเกตก็ตาม! โดยตามโครงสร้างที่เป็นทางการแล้ว สเตตเมนต์ let จะมีรูปแบบดังนี้:
let PATTERN = EXPRESSION;
ในสเตตเมนต์อย่าง let x = 5; ที่มีชื่อตัวแปรอยู่ในตำแหน่ง PATTERN นั้น ชื่อตัวแปรก็เป็นเพียงรูปแบบหนึ่งของแพตเทิร์นที่เรียบง่ายมาก โดย Rust จะเปรียบเทียบนิพจน์ทางขวากับแพตเทิร์นทางซ้าย แล้วผูกค่าเข้ากับชื่อตัวแปรทั้งหมดที่พบ ดังนั้นในตัวอย่าง let x = 5; ตัว x จึงเป็นแพตเทิร์นที่มีความหมายว่า “จงผูกค่าที่จับคู่ได้ตรงนี้เข้ากับตัวแปร x” และเพราะชื่อ x เป็นตัวแทนของแพตเทิร์นทั้งหมด มันจึงหมายถึง “ผูกค่าทุกอย่างเข้ากับตัวแปร x ไม่ว่าค่านั้นจะเป็นอะไรก็ตาม”
เพื่อให้เห็นภาพของการจับคู่แพตเทิร์น (pattern matching) ใน let ได้ชัดเจนยิ่งขึ้น ลองพิจารณาลิสติ้ง 19-1 ซึ่งใช้แพตเทิร์นร่วมกับ let เพื่อแยกส่วนโครงสร้างข้อมูล (destructure) ของทูเพิล
fn main() {
let (x, y, z) = (1, 2, 3);
}
ในที่นี้ เราได้นำทูเพิลมาจับคู่กับแพตเทิร์น โดย Rust จะเปรียบเทียบค่า (1, 2, 3) เข้ากับแพตเทิร์น (x, y, z) และพบว่าค่านั้นตรงกับแพตเทิร์น กล่าวคือ จำนวนสมาชิกของทั้งสองฝั่งเท่ากันพอดี Rust จึงผูกค่า 1 เข้ากับ x, 2 เข้ากับ y และ 3 เข้ากับ z คุณสามารถมองได้ว่าแพตเทิร์นทูเพิลนี้ คือการนำแพตเทิร์นตัวแปรเดี่ยว ๆ สามตัวมาซ้อนไว้ข้างใน
หากจำนวนสมาชิกในแพตเทิร์นไม่ตรงกับจำนวนสมาชิกในทูเพิล ชนิดข้อมูลโดยรวมจะไม่ตรงกัน และเราจะได้รับข้อผิดพลาดจากคอมไพเลอร์ ตัวอย่างเช่น ในลิสติ้ง 19-2 เราพยายามแยกส่วนทูเพิลที่มีสามสมาชิกออกเป็นสองตัวแปร ซึ่งจะทำงานไม่สำเร็จ
fn main() {
let (x, y) = (1, 2, 3);
}
การพยายามคอมไพล์โค้ดนี้จะส่งผลให้เกิดข้อผิดพลาดทางชนิดข้อมูลดังนี้:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
error[E0308]: mismatched types
--> src/main.rs:2:9
|
2 | let (x, y) = (1, 2, 3);
| ^^^^^^ --------- this expression has type `({integer}, {integer}, {integer})`
| |
| expected a tuple with 3 elements, found one with 2 elements
|
= note: expected tuple `({integer}, {integer}, {integer})`
found tuple `(_, _)`
For more information about this error, try `rustc --explain E0308`.
error: could not compile `patterns` (bin "patterns") due to 1 previous error
ในการแก้ไขข้อผิดพลาดนี้ เราสามารถเลือกที่จะละเว้นหรือเพิกเฉยต่อค่าบางค่าในทูเพิลได้โดยใช้เครื่องหมาย _ หรือ .. ดังที่คุณจะได้เห็นในหัวข้อ “การเพิกเฉยต่อค่าในแพตเทิร์น” แต่หากปัญหาเกิดจากการที่เราใส่ตัวแปรในแพตเทิร์นไว้มากเกินไป ทางแก้ก็คือปรับให้ชนิดข้อมูลตรงกัน โดยการตัดตัวแปรส่วนเกินออก เพื่อให้จำนวนตัวแปรเท่ากับจำนวนสมาชิกในทูเพิลพอดี
เอ็กซ์เพรสชัน if let แบบมีเงื่อนไข
ในบทที่ 6 เราได้อธิบายการใช้งานนิพจน์ if let โดยหลักแล้วเพื่อเป็นวิธีเขียนแบบสั้นที่เทียบเท่ากับ match ที่ต้องการจับคู่เพียงกรณีเดียว นอกจากนี้ if let ยังสามารถมีบล็อก else ควบคู่กัน ซึ่งบรรจุโค้ดที่จะทำงานเมื่อแพตเทิร์นใน if let จับคู่ไม่สำเร็จ
ลิสติ้ง 19-3 แสดงให้เห็นว่าเราสามารถนำนิพจน์ if let, else if และ else if let มาผสมผสานเข้าด้วยกันได้ ซึ่งจะให้ความยืดหยุ่นมากกว่านิพจน์ match ที่กำหนดให้เราส่งค่าเข้าเปรียบเทียบกับแพตเทิร์นได้เพียงค่าเดียว ยิ่งไปกว่านั้น Rust ไม่ได้บังคับว่าเงื่อนไขในสายของ if let, else if และ else if let จะต้องมีความเกี่ยวข้องกันแต่อย่างใด
โค้ดในลิสติ้ง 19-3 จะตัดสินใจเลือกว่าสีพื้นหลังควรเป็นสีอะไร โดยตรวจสอบเงื่อนไขหลายประการต่อเนื่องกัน สำหรับตัวอย่างนี้ เราได้สร้างตัวแปรที่กำหนดค่าคงที่ไว้ล่วงหน้า (hardcode) ซึ่งในโปรแกรมจริงอาจเป็นค่าที่ได้รับมาจากผู้ใช้
fn main() {
let favorite_color: Option<&str> = None;
let is_tuesday = false;
let age: Result<u8, _> = "34".parse();
if let Some(color) = favorite_color {
println!("Using your favorite color, {color}, as the background");
} else if is_tuesday {
println!("Tuesday is green day!");
} else if let Ok(age) = age {
if age > 30 {
println!("Using purple as the background color");
} else {
println!("Using orange as the background color");
}
} else {
println!("Using blue as the background color");
}
}
หากผู้ใช้ระบุสีที่ชอบ สีนั้นจะถูกนำไปใช้เป็นสีพื้นหลัง แต่ถ้าไม่ได้ระบุสีที่ชอบไว้และวันนี้เป็นวันอังคาร สีพื้นหลังจะกลายเป็นสีเขียว หรือหากผู้ใช้ระบุอายุเป็นสตริงและเราสามารถแปลง (parse) เป็นตัวเลขได้สำเร็จ สีพื้นหลังก็จะเป็นสีม่วงหรือสีส้มขึ้นอยู่กับค่าของตัวเลขนั้น และหากไม่ตรงกับเงื่อนไขใด ๆ เลย สีพื้นหลังก็จะเป็นสีน้ำเงิน
โครงสร้างเงื่อนไขแบบนี้ช่วยให้เรารองรับความต้องการที่ซับซ้อนได้เป็นอย่างดี จากค่าที่กำหนดไว้ในตัวอย่างนี้ โปรแกรมจะพิมพ์ Using purple as the background color
คุณจะสังเกตเห็นว่า if let สามารถประกาศตัวแปรใหม่ที่บดบัง (shadow) ตัวแปรเดิมที่มีอยู่ได้ในลักษณะเดียวกับอาร์มของ match: เช่นในบรรทัด if let Ok(age) = age จะสร้างตัวแปร age ตัวใหม่ขึ้นมาเพื่อเก็บค่าที่อยู่ภายในวาเรียนต์ Ok ซึ่งจะไปบดบังตัวแปร age ตัวเดิม สิ่งนี้ทำให้เราต้องวางเงื่อนไข if age > 30 ไว้ภายในบล็อกนั้น: เราไม่สามารถรวมเงื่อนไขทั้งสองเข้าด้วยกันเป็น if let Ok(age) = age && age > 30 ได้ เพราะตัวแปร age ตัวใหม่ที่เราต้องการนำไปเปรียบเทียบกับ 30 จะยังไม่มีผลให้เรียกใช้ได้ จนกว่าจะเริ่มขอบเขตการทำงาน (scope) ใหม่หลังวงเล็บปีกกาเปิด
ข้อเสียของการใช้นิพจน์ if let คือคอมไพเลอร์จะไม่ช่วยตรวจสอบความครอบคลุมทุกกรณี (exhaustiveness) เหมือนอย่างที่ทำให้นิพจน์ match หากเราละเว้นบล็อก else สุดท้ายไปจนทำให้ตกหล่นบางกรณี คอมไพเลอร์จะไม่สามารถแจ้งเตือนให้เราทราบถึงบั๊กทางตรรกะที่อาจเกิดขึ้นได้
ลูปแบบมีเงื่อนไข while let
ลูปแบบมีเงื่อนไข while let มีโครงสร้างคล้ายกับ if let โดยอนุญาตให้ลูป while วนทำงานต่อไปได้เรื่อย ๆ ตราบเท่าที่แพตเทิร์นยังคงจับคู่ได้สำเร็จ ในลิสติ้ง 19-4 เราจะแสดงลูป while let ที่คอยรอรับข้อความที่ส่งระหว่างเธรด (threads) แต่ในกรณีนี้จะตรวจสอบค่า Result แทนที่จะเป็น Option
fn main() {
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
for val in [1, 2, 3] {
tx.send(val).unwrap();
}
});
while let Ok(value) = rx.recv() {
println!("{value}");
}
}
ตัวอย่างนี้จะพิมพ์ 1, 2 และ 3 ออกมาตามลำดับ เมธอด recv จะดึงข้อความแรกออกจากฝั่งตัวรับของแชนเนล (channel) และคืนค่า Ok(value) กลับมา เมื่อตอนที่เราพบกับ recv ครั้งแรกในบทที่ 16 เราได้ unwrap ผลลัพธ์โดยตรง หรือไม่ก็วนลูปจัดการกับมันในฐานะอิเทอเรเตอร์ (iterator) ด้วยลูป for แต่ดังที่ลิสติ้ง 19-4 แสดงให้เห็น เราสามารถใช้ while let ได้เช่นกัน เพราะเมธอด recv จะส่งคืนค่า Ok ออกมาทุกครั้งที่มีข้อความมาถึง ตราบใดที่ฝั่งผู้ส่งยังคงอยู่ และจะคืนค่า Err เมื่อฝั่งผู้ส่งตัดการเชื่อมต่อไปแล้ว
ลูป for
ในลูป for ค่าที่ตามหลังคีย์เวิร์ด for โดยตรงก็คือแพตเทิร์น ตัวอย่างเช่น ในคำสั่ง for x in y ตัว x ก็คือแพตเทิร์น ลิสติ้ง 19-5 สาธิตการใช้แพตเทิร์นในลูป for เพื่อแยกส่วนโครงสร้างข้อมูล (destructure) ของทูเพิลออกมาขณะวนลูป
fn main() {
let v = vec!['a', 'b', 'c'];
for (index, value) in v.iter().enumerate() {
println!("{value} is at index {index}");
}
}
โค้ดในลิสติ้ง 19-5 จะพิมพ์ผลลัพธ์ต่อไปนี้ออกมา:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.52s
Running `target/debug/patterns`
a is at index 0
b is at index 1
c is at index 2
เราปรับแต่งอิเทอเรเตอร์ด้วยเมธอด enumerate เพื่อให้ส่งคืนค่าพร้อมกับดัชนี (index) ของค่านั้นออกมาเป็นคู่ทูเพิล โดยค่าแรกที่ได้คือทูเพิล (0, 'a') และเมื่อนำไปจับคู่กับแพตเทิร์น (index, value) ตัวแปร index ก็จะได้ค่า 0 และ value ได้ค่า 'a' จึงพิมพ์บรรทัดแรกของผลลัพธ์ออกมา
พารามิเตอร์ของฟังก์ชัน
พารามิเตอร์ของฟังก์ชันก็สามารถเป็นแพตเทิร์นได้เช่นกัน โค้ดในลิสติ้ง 19-6 ซึ่งประกาศฟังก์ชันชื่อ foo ที่รับพารามิเตอร์หนึ่งตัวชื่อ x ชนิด i32 ตอนนี้น่าจะดูคุ้นตาเป็นอย่างดีแล้ว
fn foo(x: i32) {
// code goes here
}
fn main() {}
ส่วน x ตรงนั้นก็คือแพตเทิร์น! เช่นเดียวกับที่เราทำกับ let เราสามารถนำแพตเทิร์นมาจับคู่กับทูเพิลในอาร์กิวเมนต์ของฟังก์ชันได้ ลิสติ้ง 19-7 แสดงการแยกส่วนค่าในทูเพิลขณะส่งผ่านเข้าไปยังฟังก์ชัน
fn print_coordinates(&(x, y): &(i32, i32)) {
println!("Current location: ({x}, {y})");
}
fn main() {
let point = (3, 5);
print_coordinates(&point);
}
โค้ดนี้จะพิมพ์ Current location: (3, 5) ออกมา โดยค่า &(3, 5) จะจับคู่เข้ากับแพตเทิร์น &(x, y) ทำให้ x ได้รับค่า 3 และ y ได้รับค่า 5
นอกจากนี้ เรายังสามารถใช้แพตเทิร์นในรายการพารามิเตอร์ของโคลเชอร์ (closure) ได้ในทำนองเดียวกับพารามิเตอร์ของฟังก์ชัน เพราะโคลเชอร์มีลักษณะคล้ายคลึงกับฟังก์ชันดังที่เราได้พูดคุยกันไปในบทที่ 13
มาถึงจุดนี้ คุณได้เห็นวิธีนำแพตเทิร์นไปประยุกต์ใช้ในหลากหลายรูปแบบแล้ว แต่แพตเทิร์นไม่ได้มีพฤติกรรมเหมือนกันหมดในทุกตำแหน่ง ในบางจุด แพตเทิร์นจำเป็นต้องเป็นแบบที่จับคู่สำเร็จเสมอ (irrefutable) ขณะที่ในบางสถานการณ์ ก็สามารถเป็นแบบที่อาจจับคู่ไม่สำเร็จได้ (refutable) เราจะไปเจาะลึกสองแนวคิดนี้กันในหัวข้อถัดไป