วากยสัมพันธ์ของแพตเทิร์น
ในหัวข้อนี้ เรารวบรวมไวยากรณ์และรูปแบบทั้งหมดที่ใช้ได้กับแพตเทิร์น (pattern) รวมถึงพูดคุยว่าเหตุใดและเมื่อใดที่คุณควรเลือกใช้งานแต่ละรูปแบบ
การจับคู่ค่าลิเทอรัล
ดังที่คุณได้เห็นในบทที่ 6 เราสามารถนำแพตเทิร์นไปจับคู่กับค่าลิเทอรัล (literal) ได้โดยตรง ดังตัวอย่างโค้ดต่อไปนี้:
fn main() {
let x = 1;
match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
_ => println!("anything"),
}
}
โค้ดนี้จะพิมพ์ one ออกมา เนื่องจากค่าใน x คือ 1 ไวยากรณ์รูปแบบนี้มีประโยชน์อย่างยิ่งเมื่อคุณต้องการให้โค้ดทำงานบางอย่าง เมื่อได้รับค่าที่เจาะจงค่าใดค่าหนึ่งโดยเฉพาะ
การจับคู่ตัวแปรที่มีชื่อ
ตัวแปรที่มีชื่อจัดเป็นแพตเทิร์นที่จับคู่สำเร็จเสมอ (irrefutable pattern) ซึ่งสามารถจับคู่ได้กับทุกค่า และเราได้ใช้งานรูปแบบนี้กันมาหลายครั้งตลอดทั้งเล่ม อย่างไรก็ตาม ความซับซ้อนจะเกิดขึ้นเมื่อคุณนำตัวแปรที่มีชื่อไปใช้ในนิพจน์ match, if let หรือ while let เนื่องจากนิพจน์เหล่านี้จะสร้างสโคปใหม่ขึ้นมาเสมอ ตัวแปรที่ประกาศขึ้นเป็นส่วนหนึ่งของแพตเทิร์นภายในนิพจน์เหล่านี้จึงจะไปบดบัง (shadow) ตัวแปรที่มีชื่อเดียวกันซึ่งอยู่นอกโครงสร้างคำสั่งนั้น เช่นเดียวกับพฤติกรรมปกติของตัวแปรทั่วไป ในลิสติ้ง 19-11 เราประกาศตัวแปรชื่อ x ที่เก็บค่า Some(5) และตัวแปร y ที่เก็บค่า 10 จากนั้นสร้างนิพจน์ match สำหรับค่า x ลองพิจารณาแพตเทิร์นในแต่ละอาร์มของ match และคำสั่ง println! ตอนท้าย แล้วลองคาดเดาดูว่าโค้ดจะพิมพ์อะไรออกมาก่อนที่คุณจะรันโค้ดหรืออ่านคำอธิบายถัดไป
fn main() {
let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
Some(y) => println!("Matched, y = {y}"),
_ => println!("Default case, x = {x:?}"),
}
println!("at the end: x = {x:?}, y = {y}");
}
มาดูการทำงานทีละขั้นเมื่อนิพจน์ match ทำงานกัน แพตเทิร์นในอาร์มแรกของ match จะจับคู่ไม่ตรงกับค่า x ที่กำหนดไว้ โค้ดจึงทำงานต่อไปยังอาร์มถัดไป
แพตเทิร์นในอาร์มที่สองของ match ประกาศตัวแปรใหม่ชื่อ y ซึ่งจะจับคู่กับค่าใดก็ตามที่อยู่ภายในค่า Some และเนื่องจากเราอยู่ในสโคปใหม่ภายในนิพจน์ match นี่จึงเป็นตัวแปร y ตัวใหม่ ไม่ใช่ตัวแปร y ที่เราประกาศไว้ตอนต้นด้วยค่า 10 การผูกค่า (binding) y ใหม่นี้จะจับคู่กับค่าใดก็ได้ที่อยู่ภายใน Some ซึ่งก็คือค่าที่มีอยู่ใน x ดังนั้น y ใหม่นี้จึงผูกเข้ากับค่าภายในของ Some ใน x ซึ่งมีค่าเป็น 5 นิพจน์ของอาร์มนั้นจึงทำงานและพิมพ์ Matched, y = 5 ออกมา
หาก x มีค่าเป็น None แทนที่จะเป็น Some(5) แพตเทิร์นในสองอาร์มแรกจะไม่ตรงเงื่อนไข ค่านั้นจึงจะถูกจับคู่ด้วยเครื่องหมายขีดล่าง (underscore) และเนื่องจากเราไม่ได้ประกาศตัวแปร x ขึ้นมาใหม่ในแพตเทิร์นของอาร์มขีดล่าง ตัวแปร x ในบล็อกนั้นจึงยังคงเป็น x ตัวนอกที่ไม่ถูกบดบัง ในกรณีสมมตินี้ match จะพิมพ์ Default case, x = None
เมื่อนิพจน์ match ทำงานเสร็จสิ้น สโคปของมันก็จะสิ้นสุดลง และสโคปของ y ตัวในก็สิ้นสุดลงด้วยเช่นกัน คำสั่ง println! ตัวสุดท้ายจึงให้ผลลัพธ์เป็น at the end: x = Some(5), y = 10
หากเราต้องการสร้างนิพจน์ match ที่เปรียบเทียบค่าของ x กับ y ตัวนอก แทนที่จะเป็นการประกาศตัวแปรใหม่ที่บดบังตัวแปร y เดิม เราจะต้องใช้เงื่อนไขการ์ด match (match guard) เข้ามาช่วย ซึ่งเราจะอธิบายเรื่องการ์ด match ต่อไปในหัวข้อ“การเพิ่มเงื่อนไขด้วยการ์ด match”
การจับคู่หลายแพตเทิร์น
ในนิพจน์ match คุณสามารถจับคู่กับหลายแพตเทิร์นได้ด้วยสัญลักษณ์ | ซึ่งทำหน้าที่เป็นตัวดำเนินการ หรือ (or) ของแพตเทิร์น ตัวอย่างเช่น ในโค้ดต่อไปนี้ เราจับคู่ค่าของ x กับอาร์มต่าง ๆ ของ match โดยอาร์มแรกมีตัวเลือกแบบ หรือ ซึ่งหมายความว่าหากค่าของ x ตรงกับค่าใดค่าหนึ่งในอาร์มนั้น โค้ดของอาร์มดังกล่าวก็จะทำงาน:
fn main() {
let x = 1;
match x {
1 | 2 => println!("one or two"),
3 => println!("three"),
_ => println!("anything"),
}
}
โค้ดนี้จะพิมพ์ one or two
การจับคู่ช่วงของค่าด้วย ..=
ไวยากรณ์ ..= ช่วยให้เราจับคู่กับช่วงของค่าแบบรวมจุดสิ้นสุด (inclusive range) ได้ ในโค้ดต่อไปนี้ เมื่อแพตเทิร์นจับคู่ตรงกับค่าใดก็ตามที่อยู่ภายในช่วงที่กำหนด อาร์มนั้นจะทำงาน:
fn main() {
let x = 5;
match x {
1..=5 => println!("one through five"),
_ => println!("something else"),
}
}
หาก x มีค่าเป็น 1, 2, 3, 4 หรือ 5 อาร์มแรกจะจับคู่สำเร็จ ไวยากรณ์นี้สะดวกกว่าการใช้ตัวดำเนินการ | เพื่อจับคู่หลาย ๆ ค่ามาก เพราะหากใช้ | เราจะต้องเขียนยาวเป็น 1 | 2 | 3 | 4 | 5 การกำหนดช่วงจึงกระชับกว่ากันมาก โดยเฉพาะอย่างยิ่งหากเราต้องการจับคู่กับตัวเลขจำนวนมาก เช่น ระหว่าง 1 ถึง 1,000!
คอมไพเลอร์จะตรวจสอบตั้งแต่ตอนคอมไพล์ว่าช่วงนั้นไม่ว่างเปล่า และเนื่องจากชนิดข้อมูลเดียวที่ Rust ตรวจสอบได้ว่าช่วงว่างเปล่าหรือไม่คือ char และชนิดข้อมูลตัวเลข การกำหนดช่วงจึงใช้ได้เฉพาะกับค่าตัวเลขหรือค่า char เท่านั้น
ตัวอย่างการใช้ช่วงกับค่าชนิด char:
fn main() {
let x = 'c';
match x {
'a'..='j' => println!("early ASCII letter"),
'k'..='z' => println!("late ASCII letter"),
_ => println!("something else"),
}
}
Rust สามารถตรวจสอบได้ว่า 'c' อยู่ในช่วงของแพตเทิร์นแรก จึงพิมพ์ early ASCII letter ออกมา
การแยกโครงสร้างข้อมูลเพื่อแยกชิ้นส่วนค่า
เรายังสามารถใช้แพตเทิร์นเพื่อแยกส่วนประกอบหรือแยกโครงสร้างข้อมูล (destructure) ของ struct, enum และทูเพิล เพื่อนำชิ้นส่วนต่าง ๆ ของค่าเหล่านี้ไปใช้งานได้ ลองมาดูทีละกรณีกัน
struct
ในลิสติ้ง 19-12 แสดง struct Point ที่มีสองฟิลด์ (field) คือ x และ y ซึ่งเราสามารถแยกส่วนประกอบออกมาได้โดยใช้แพตเทิร์นร่วมกับสเตตเมนต์ let
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 0, y: 7 };
let Point { x: a, y: b } = p;
assert_eq!(0, a);
assert_eq!(7, b);
}
โค้ดนี้จะสร้างตัวแปร a และ b ที่จับคู่กับค่าของฟิลด์ x และ y ของ struct p ตัวอย่างนี้แสดงให้เห็นว่าชื่อของตัวแปรในแพตเทิร์นไม่จำเป็นต้องตรงกับชื่อฟิลด์ของ struct เสมอไป อย่างไรก็ตาม ในทางปฏิบัตินิยมตั้งชื่อตัวแปรให้ตรงกับชื่อฟิลด์เพื่อให้จดจำได้ง่ายว่าตัวแปรใดมาจากฟิลด์ไหน และเนื่องจากกรณีการใช้งานเช่นนี้พบได้บ่อยมาก ประกอบกับการเขียน let Point { x: x, y: y } = p; ก็มีส่วนซ้ำซ้อนกันอยู่ Rust จึงมีไวยากรณ์แบบย่อ (shorthand) สำหรับแพตเทิร์นที่จับคู่กับฟิลด์ของ struct โดยคุณเพียงแค่ระบุชื่อฟิลด์ของ struct เท่านั้น แล้วตัวแปรที่ถูกสร้างจากแพตเทิร์นก็จะมีชื่อเดียวกับฟิลด์นั้นโดยอัตโนมัติ ลิสติ้ง 19-13 ทำงานเหมือนกับโค้ดในลิสติ้ง 19-12 ทุกประการ เพียงแต่ตัวแปรที่ถูกสร้างในแพตเทิร์น let จะเป็น x และ y แทนที่จะเป็น a และ b
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 0, y: 7 };
let Point { x, y } = p;
assert_eq!(0, x);
assert_eq!(7, y);
}
โค้ดนี้จะสร้างตัวแปร x และ y ที่จับคู่กับฟิลด์ x และ y ของตัวแปร p ส่งผลให้ตัวแปร x และ y ได้รับค่ามาจาก struct p
นอกจากนี้ เรายังสามารถแยกโครงสร้างข้อมูลร่วมกับการจับคู่ค่าลิเทอรัลในแพตเทิร์นของ struct ได้ แทนที่จะต้องสร้างตัวแปรให้กับทุก ๆ ฟิลด์ วิธีนี้ช่วยให้เราตรวจสอบค่าที่เจาะจงในบางฟิลด์ พร้อมกับสร้างตัวแปรเพื่อดึงค่าจากฟิลด์อื่น ๆ ออกมาได้พร้อมกัน
ในลิสติ้ง 19-14 เรามีนิพจน์ match ที่แยกค่า Point ออกเป็นสามกรณี ได้แก่: จุดที่อยู่บนแกน x (ซึ่งเป็นจริงเมื่อ y = 0), จุดที่อยู่บนแกน y (x = 0) หรือจุดที่ไม่อยู่บนแกนใดเลย
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point { x: 0, y: 7 };
match p {
Point { x, y: 0 } => println!("On the x axis at {x}"),
Point { x: 0, y } => println!("On the y axis at {y}"),
Point { x, y } => {
println!("On neither axis: ({x}, {y})");
}
}
}
อาร์มแรกจะจับคู่กับจุดใดก็ตามที่อยู่บนแกน x โดยกำหนดเงื่อนไขว่าฟิลด์ y จะจับคู่สำเร็จหากมีค่าตรงกับลิเทอรัล 0 พร้อมทั้งสร้างตัวแปร x ขึ้นมาเพื่อให้เรานำไปใช้ในโค้ดของอาร์มนั้นได้
ในทำนองเดียวกัน อาร์มที่สองจะจับคู่กับจุดใดก็ตามที่อยู่บนแกน y โดยระบุว่าฟิลด์ x จะจับคู่สำเร็จหากมีค่าเป็น 0 และสร้างตัวแปร y สำหรับค่าของฟิลด์ y ส่วนอาร์มที่สามไม่ได้ระบุค่าลิเทอรัลใด ๆ ไว้ จึงจะจับคู่กับ Point อื่น ๆ ที่เหลือทั้งหมด และสร้างตัวแปรสำหรับทั้งฟิลด์ x และ y
ในตัวอย่างนี้ ค่า p จะจับคู่เข้ากับอาร์มที่สองเนื่องจาก x มีค่าเป็น 0 โค้ดนี้จึงพิมพ์ On the y axis at 7
โปรดจำไว้ว่านิพจน์ match จะหยุดตรวจสอบอาร์มทันทีที่พบแพตเทิร์นแรกที่จับคู่ตรงเงื่อนไข ดังนั้นแม้ว่า Point { x: 0, y: 0 } จะอยู่ทั้งบนแกน x และแกน y แต่โค้ดนี้ก็จะพิมพ์เพียง On the x axis at 0 เท่านั้น
enum
เราเคยแยกโครงสร้างข้อมูลของ enum กันมาแล้วในหนังสือเล่มนี้ (ตัวอย่างเช่น ลิสติ้ง 6-5 ในบทที่ 6) แต่ยังไม่ได้อธิบายอย่างชัดเจนว่าแพตเทิร์นในการแยกโครงสร้างข้อมูลของ enum นั้น สอดคล้องกับวิธีที่ข้อมูลภายในแต่ละตัวแปรของ enum ถูกนิยามไว้อย่างไร ตัวอย่างเช่น ในลิสติ้ง 19-15 เราจะนำ enum Message จากลิสติ้ง 6-2 มาเขียนนิพจน์ match ด้วยแพตเทิร์นที่แยกโครงสร้างข้อมูลค่าภายในของแต่ละกรณีออกมา
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
fn main() {
let msg = Message::ChangeColor(0, 160, 255);
match msg {
Message::Quit => {
println!("The Quit variant has no data to destructure.");
}
Message::Move { x, y } => {
println!("Move in the x direction {x} and in the y direction {y}");
}
Message::Write(text) => {
println!("Text message: {text}");
}
Message::ChangeColor(r, g, b) => {
println!("Change color to red {r}, green {g}, and blue {b}");
}
}
}
โค้ดนี้จะพิมพ์ Change color to red 0, green 160, and blue 255 ลองเปลี่ยนค่าของ msg เพื่อดูผลการทำงานจากอาร์มอื่น ๆ
สำหรับวาเรียนต์ (variant) ของ enum ที่ไม่มีข้อมูลแนบมาด้วย เช่น Message::Quit เราจะไม่สามารถแยกโครงสร้างข้อมูลได้อีก ทำได้เพียงจับคู่กับค่าลิเทอรัล Message::Quit ตรง ๆ และไม่มีตัวแปรใดอยู่ในแพตเทิร์นนั้น
สำหรับวาเรียนต์ของ enum ที่มีลักษณะคล้าย struct เช่น Message::Move เราสามารถใช้แพตเทิร์นในลักษณะเดียวกับตอนที่จับคู่ struct ได้ โดยใส่วงเล็บปีกกา {} ต่อท้ายชื่อวาเรียนต์แล้วระบุชื่อฟิลด์พร้อมตัวแปร เพื่อแยกค่าออกมาใช้ในโค้ดของอาร์มนั้น ซึ่งในที่นี้เราใช้ไวยากรณ์แบบย่อเหมือนกับในลิสติ้ง 19-13
สำหรับวาเรียนต์ของ enum ที่มีลักษณะคล้ายทูเพิล เช่น Message::Write ที่เก็บทูเพิลที่มีสมาชิกหนึ่งตัว และ Message::ChangeColor ที่เก็บทูเพิลที่มีสมาชิกสามตัว แพตเทิร์นจะมีลักษณะเดียวกับการจับคู่ทูเพิล โดยจำนวนตัวแปรในแพตเทิร์นจะต้องตรงกับจำนวนสมาชิกภายในวาเรียนต์นั้น ๆ พอดี
struct และ enum ที่ซ้อนกัน
จนถึงจุดนี้ ตัวอย่างทั้งหมดเป็นการจับคู่กับ struct หรือ enum ที่มีความลึกเพียงชั้นเดียว แต่การจับคู่แพตเทิร์นยังสามารถทำงานกับข้อมูลที่มีโครงสร้างซ้อนกัน (nested) ได้อีกด้วย! เช่น เราสามารถปรับโครงสร้างโค้ดในลิสติ้ง 19-15 เพื่อรองรับทั้งระบบสี RGB และ HSV ในข้อความ ChangeColor ดังแสดงในลิสติ้ง 19-16
enum Color {
Rgb(i32, i32, i32),
Hsv(i32, i32, i32),
}
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(Color),
}
fn main() {
let msg = Message::ChangeColor(Color::Hsv(0, 160, 255));
match msg {
Message::ChangeColor(Color::Rgb(r, g, b)) => {
println!("Change color to red {r}, green {g}, and blue {b}");
}
Message::ChangeColor(Color::Hsv(h, s, v)) => {
println!("Change color to hue {h}, saturation {s}, value {v}");
}
_ => (),
}
}
แพตเทิร์นของอาร์มแรกในนิพจน์ match จะจับคู่กับวาเรียนต์ Message::ChangeColor ของ enum ที่มีวาเรียนต์ Color::Rgb ซ้อนอยู่ภายใน จากนั้นแพตเทิร์นจะผูกเข้ากับค่า i32 สามค่าที่อยู่ข้างใน ส่วนแพตเทิร์นของอาร์มที่สองก็จับคู่กับวาเรียนต์ Message::ChangeColor ของ enum เช่นกัน แต่วาเรียนต์ภายในจะจับคู่กับ Color::Hsv แทน เราสามารถระบุเงื่อนไขที่ซับซ้อนเหล่านี้ได้ครบถ้วนภายในนิพจน์ match เดียว แม้ว่าจะมี enum สองชนิดเข้ามาเกี่ยวข้องก็ตาม
struct และทูเพิล
เรายังสามารถผสมผสาน จับคู่ และซ้อนแพตเทิร์นการแยกโครงสร้างข้อมูลในรูปแบบที่ซับซ้อนยิ่งขึ้นได้ ตัวอย่างต่อไปนี้แสดงการแยกโครงสร้างข้อมูลที่ซับซ้อน โดยเราซ้อนทั้ง struct และทูเพิลไว้ภายในทูเพิลอีกชั้นหนึ่ง แล้วดึงค่าพื้นฐาน (primitive) ทั้งหมดออกมา:
fn main() {
struct Point {
x: i32,
y: i32,
}
let ((feet, inches), Point { x, y }) = ((3, 10), Point { x: 3, y: -10 });
}
โค้ดนี้ช่วยให้เราแยกชนิดข้อมูลที่ซับซ้อนออกเป็นส่วนประกอบย่อย ๆ เพื่อให้เรานำค่าที่สนใจไปใช้งานแยกกันได้
การแยกโครงสร้างข้อมูลด้วยแพตเทิร์นเป็นวิธีที่สะดวกอย่างยิ่งในการดึงค่าบางส่วน เช่น ค่าจากแต่ละฟิลด์ใน struct ออกมาใช้งานแยกกันอย่างอิสระ
การเพิกเฉยต่อค่าในแพตเทิร์น
คุณได้เห็นแล้วว่าในบางครั้ง การละเว้นหรือไม่สนใจค่าในแพตเทิร์นก็มีประโยชน์ เช่น ในอาร์มสุดท้ายของ match เพื่อให้ได้แพตเทิร์นแบบครอบคลุมทั้งหมดที่ไม่ต้องทำอะไร แต่สามารถรองรับค่าที่เป็นไปได้ทั้งหมดที่เหลืออยู่ มีหลายวิธีในการละเว้นค่าทั้งหมดหรือบางส่วนในแพตเทิร์น: ได้แก่ การใช้แพตเทิร์น _ (ดังที่คุณได้เห็นมาแล้ว), การใช้แพตเทิร์น _ ซ้อนอยู่ภายในแพตเทิร์นอื่น, การใช้ชื่อตัวแปรที่ขึ้นต้นด้วยเครื่องหมายขีดล่าง หรือการใช้ .. เพื่อละเว้นส่วนที่เหลือของค่า ลองมาสำรวจวิธีการและเหตุผลในการใช้แพตเทิร์นแต่ละแบบเหล่านี้กัน
ทั้งค่าด้วย _
เราใช้เครื่องหมายขีดล่าง (underscore) เป็นแพตเทิร์นไวลด์การ์ด (wildcard) ที่จะจับคู่กับค่าใดก็ได้ แต่จะไม่ผูกค่านั้นไว้กับตัวแปร รูปแบบนี้มีประโยชน์อย่างยิ่งในอาร์มสุดท้ายของนิพจน์ match แต่ก็สามารถนำไปใช้ในแพตเทิร์นใด ๆ ก็ได้เช่นกัน รวมถึงในพารามิเตอร์ของฟังก์ชัน ดังแสดงในลิสติ้ง 19-17
fn foo(_: i32, y: i32) {
println!("This code only uses the y parameter: {y}");
}
fn main() {
foo(3, 4);
}
โค้ดนี้จะไม่สนใจค่า 3 ที่ส่งเข้ามาเป็นอาร์กิวเมนต์แรกโดยสิ้นเชิง และจะพิมพ์ This code only uses the y parameter: 4 ออกมา
โดยทั่วไป หากคุณไม่จำเป็นต้องใช้พารามิเตอร์ของฟังก์ชันตัวใดตัวหนึ่งแล้ว คุณก็มักจะแก้ไขซิกเนเจอร์เพื่อตัดพารามิเตอร์นั้นออกไปเลย แต่การละเว้นพารามิเตอร์ของฟังก์ชันด้วย _ นั้นมีประโยชน์อย่างมากในกรณีเช่น การอิมพลีเมนต์เทรตที่บังคับโครงสร้างซิกเนเจอร์ของฟังก์ชันไว้ แต่บอดี้ของฟังก์ชันในการอิมพลีเมนต์ของคุณไม่จำเป็นต้องใช้พารามิเตอร์ตัวใดตัวหนึ่ง การใช้ _ จะช่วยป้องกันไม่ให้คอมไพเลอร์แจ้งคำเตือนเกี่ยวกับพารามิเตอร์ที่ไม่ได้ใช้ ซึ่งจะเกิดขึ้นหากคุณตั้งชื่อให้พารามิเตอร์นั้น
การเพิกเฉยต่อบางส่วนของค่าด้วย _ ที่ซ้อนกัน
เรายังสามารถใช้ _ ซ้อนอยู่ภายในแพตเทิร์นอื่นเพื่อละเว้นเพียงบางส่วนของค่าได้ เช่น เมื่อเราต้องการทดสอบเพียงบางส่วนของข้อมูลแต่ไม่ได้นำส่วนที่เหลือไปใช้งานในโค้ด ลิสติ้ง 19-18 แสดงโค้ดสำหรับจัดการค่าการตั้งค่า โดยมีกฎทางธุรกิจว่า ผู้ใช้จะต้องไม่สามารถเขียนทับการตั้งค่าที่ถูกปรับแต่งไว้แล้วได้ แต่สามารถล้างการตั้งค่าเดิม และกำหนดค่าใหม่ให้ได้หากปัจจุบันยังไม่ได้ตั้งค่าไว้
fn main() {
let mut setting_value = Some(5);
let new_setting_value = Some(10);
match (setting_value, new_setting_value) {
(Some(_), Some(_)) => {
println!("Can't overwrite an existing customized value");
}
_ => {
setting_value = new_setting_value;
}
}
println!("setting is {setting_value:?}");
}
โค้ดนี้จะพิมพ์ Can't overwrite an existing customized value ตามด้วย setting is Some(5) ในอาร์มแรกของ match เราไม่จำเป็นต้องตรวจสอบหรือนำค่าที่อยู่ภายใน Some มาใช้งาน แต่เราต้องการทดสอบกรณีที่ทั้ง setting_value และ new_setting_value ต่างเป็นวาเรียนต์ Some ซึ่งในกรณีนี้ เราจะพิมพ์ข้อความบอกเหตุผลที่ไม่เปลี่ยนแปลง setting_value และค่านั้นจะไม่ถูกแก้ไข
ในกรณีอื่น ๆ ทั้งหมด (เมื่อ setting_value หรือ new_setting_value ตัวใดตัวหนึ่งเป็น None) ซึ่งแทนด้วยแพตเทิร์น _ ในอาร์มที่สอง เราจะอนุญาตให้ new_setting_value กลายเป็นค่าใหม่ของ setting_value
นอกจากนี้ เรายังสามารถใช้เครื่องหมายขีดล่างในหลายตำแหน่งภายในแพตเทิร์นเดียวกันเพื่อละเว้นค่าที่เจาะจงได้ ลิสติ้ง 19-19 แสดงตัวอย่างการละเว้นค่าลำดับที่สองและสี่ในทูเพิลที่มีสมาชิก 5 ตัว
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(first, _, third, _, fifth) => {
println!("Some numbers: {first}, {third}, {fifth}");
}
}
}
โค้ดนี้จะพิมพ์ Some numbers: 2, 8, 32 โดยที่ค่า 4 และ 16 จะถูกละเว้นไป
ตัวแปรที่ไม่ได้ใช้โดยขึ้นต้นชื่อด้วย _
หากคุณสร้างตัวแปรขึ้นมาแต่ไม่ได้นำไปใช้งานที่ไหนเลย Rust มักจะแจ้งคำเตือน เพราะตัวแปรที่ไม่ได้ใช้อาจเป็นสัญญาณของบั๊กได้ อย่างไรก็ตาม บางครั้งการสร้างตัวแปรที่ยังไม่ได้ใช้ก็มีประโยชน์ เช่น ตอนที่คุณกำลังสร้างตัวอย่างต้นแบบ (prototype) หรือเพิ่งเริ่มโปรเจกต์ ในสถานการณ์นี้ คุณสามารถบอกให้ Rust ไม่ต้องแจ้งเตือนเกี่ยวกับตัวแปรที่ไม่ได้ใช้ได้ โดยการขึ้นต้นชื่อตัวแปรด้วยเครื่องหมายขีดล่าง ในลิสติ้ง 19-20 เราสร้างตัวแปรที่ไม่ได้ใช้สองตัว แต่เมื่อคอมไพล์โค้ดนี้ เราจะได้รับคำเตือนสำหรับตัวแปรเพียงตัวเดียวเท่านั้น
fn main() {
let _x = 5;
let y = 10;
}
ในที่นี้ เราจะได้รับคำเตือนเกี่ยวกับการไม่ใช้งานตัวแปร y แต่จะไม่ได้รับคำเตือนเกี่ยวกับ _x
โปรดสังเกตว่า มีความแตกต่างที่สำคัญระหว่างการใช้ _ เดี่ยว ๆ กับการใช้ชื่อที่ขึ้นต้นด้วยขีดล่าง: โดยไวยากรณ์ _x ยังคงผูกค่านั้นเข้ากับตัวแปรอยู่ ในขณะที่ _ เพียงอย่างเดียวจะไม่ผูกค่าใด ๆ เลย เพื่อให้เห็นว่าความแตกต่างนี้ส่งผลอย่างไร ลิสติ้ง 19-21 แสดงตัวอย่างโค้ดที่จะทำให้เกิดข้อผิดพลาด
fn main() {
let s = Some(String::from("Hello!"));
if let Some(_s) = s {
println!("found a string");
}
println!("{s:?}");
}
เราจะพบข้อผิดพลาดเนื่องจากค่าของ s ยังคงถูกย้าย (move) ไปยังตัวแปร _s ซึ่งทำให้เราไม่สามารถนำ s มาใช้งานซ้ำได้อีก แต่ในทางกลับกัน การใช้เครื่องหมายขีดล่างเดี่ยว ๆ จะไม่เคยผูกค่าเลย โค้ดในลิสติ้ง 19-22 จึงสามารถคอมไพล์ผ่านได้โดยไม่มีข้อผิดพลาดใด ๆ เนื่องจาก s ไม่ได้ถูกย้ายไปยัง _
fn main() {
let s = Some(String::from("Hello!"));
if let Some(_) = s {
println!("found a string");
}
println!("{s:?}");
}
โค้ดนี้ทำงานได้ตามปกติเพราะเราไม่เคยผูกค่า s เข้ากับสิ่งใด จึงไม่มีการย้ายค่าเกิดขึ้น
ส่วนที่เหลือของค่าด้วย ..
สำหรับค่าที่ประกอบด้วยหลายส่วน เราสามารถใช้ไวยากรณ์ .. เพื่อระบุเฉพาะส่วนที่สนใจและละเว้นส่วนที่เหลือได้ โดยไม่จำเป็นต้องใส่เครื่องหมายขีดล่างทีละตัว แพตเทิร์น .. จะละเว้นทุกชิ้นส่วนของค่าที่เราไม่ได้ระบุไว้อย่างชัดเจนในแพตเทิร์น ในลิสติ้ง 19-23 เรามี struct Point ที่เก็บพิกัดในระบบ 3 มิติ และในนิพจน์ match เราต้องการประมวลผลเฉพาะพิกัด x เท่านั้น โดยไม่สนใจค่าในฟิลด์ y และ z
fn main() {
struct Point {
x: i32,
y: i32,
z: i32,
}
let origin = Point { x: 0, y: 0, z: 0 };
match origin {
Point { x, .. } => println!("x is {x}"),
}
}
เราเพียงแค่ระบุฟิลด์ x แล้วตามด้วยแพตเทิร์น .. วิธีนี้รวดเร็วกว่าการต้องเขียน y: _ และ z: _ มาก โดยเฉพาะเมื่อต้องจัดการกับ struct ที่มีฟิลด์จำนวนมากแต่เราสนใจเพียงหนึ่งหรือสองฟิลด์เท่านั้น
ไวยากรณ์ .. จะขยายครอบคลุมจำนวนค่าเท่าที่จำเป็นโดยอัตโนมัติ ลิสติ้ง 19-24 แสดงวิธีนำ .. ไปใช้กับทูเพิล
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(first, .., last) => {
println!("Some numbers: {first}, {last}");
}
}
}
ในโค้ดนี้ ค่าแรกและค่าสุดท้ายจะถูกจับคู่เข้ากับตัวแปร first และ last ส่วน .. จะจับคู่และละเว้นทุกค่าที่อยู่ตรงกลาง
อย่างไรก็ตาม การใช้ .. จะต้องไม่กำกวม หากคอมไพเลอร์ไม่สามารถแยกแยะได้ชัดเจนว่าค่าใดต้องจับคู่และค่าใดต้องละเว้น Rust จะแจ้งข้อผิดพลาดทันที ลิสติ้ง 19-25 แสดงตัวอย่างการใช้ .. ในลักษณะที่กำกวม ซึ่งจะคอมไพล์ไม่ผ่าน
fn main() {
let numbers = (2, 4, 8, 16, 32);
match numbers {
(.., second, ..) => {
println!("Some numbers: {second}")
},
}
}
เมื่อเราคอมไพล์ตัวอย่างนี้ เราจะได้ข้อผิดพลาดดังนี้:
$ cargo run
Compiling patterns v0.1.0 (file:///projects/patterns)
error: `..` can only be used once per tuple pattern
--> src/main.rs:5:22
|
5 | (.., second, ..) => {
| -- ^^ can only be used once per tuple pattern
| |
| previously used here
error: could not compile `patterns` (bin "patterns") due to 1 previous error
Rust ไม่มีทางรู้ได้เลยว่าต้องละเว้นค่าไปกี่ตัวในทูเพิลก่อนที่จะนำค่ามาจับคู่กับ second และหลังจากนั้นจะต้องละเว้นต่อไปอีกกี่ตัว โค้ดนี้อาจหมายถึงการละเว้น 2, ผูก second เข้ากับ 4 แล้วละเว้น 8, 16, 32 หรืออาจหมายถึงการละเว้น 2 กับ 4, ผูก second เข้ากับ 8 แล้วละเว้น 16 กับ 32 เป็นต้น ชื่อตัวแปร second ไม่ได้มีความหมายพิเศษอะไรสำหรับ Rust ดังนั้นเราจึงได้รับข้อผิดพลาดจากคอมไพเลอร์ เนื่องจากการใช้ .. สองตำแหน่งเช่นนี้ทำให้เกิดความกำกวม
การเพิ่มเงื่อนไขด้วยการ์ด match
การ์ด match (match guard) คือเงื่อนไข if เพิ่มเติมที่ระบุไว้หลังแพตเทิร์นในอาร์มของ match ซึ่งเงื่อนไขนี้จะต้องเป็นจริงด้วย อาร์มนั้นจึงจะถูกเลือกทำงาน การ์ด match มีประโยชน์อย่างมากในการแสดงตรรกะที่ซับซ้อนเกินกว่าที่ตัวแพตเทิร์นเพียงอย่างเดียวจะทำได้ อย่างไรก็ตาม โปรดทราบว่าการ์ด match ใช้งานได้เฉพาะในนิพจน์ match เท่านั้น ไม่สามารถใช้ในนิพจน์ if let หรือ while let ได้
เงื่อนไขดังกล่าวยังสามารถเข้าถึงตัวแปรที่ถูกสร้างขึ้นในแพตเทิร์นได้ด้วย ลิสติ้ง 19-26 แสดงนิพจน์ match ที่อาร์มแรกมีแพตเทิร์น Some(x) พร้อมการ์ด match if x % 2 == 0 (ซึ่งจะเป็น true เมื่อตัวเลขเป็นจำนวนคู่)
fn main() {
let num = Some(4);
match num {
Some(x) if x % 2 == 0 => println!("The number {x} is even"),
Some(x) => println!("The number {x} is odd"),
None => (),
}
}
ตัวอย่างนี้จะพิมพ์ The number 4 is even ออกมา เมื่อนำ num ไปเปรียบเทียบกับแพตเทิร์นในอาร์มแรก จะพบว่าจับคู่ได้สำเร็จเพราะ Some(4) ตรงกับ Some(x) จากนั้นการ์ด match จะตรวจสอบต่อว่าเศษจากการหาร x ด้วย 2 เท่ากับ 0 หรือไม่ และเนื่องจากเท่ากับ 0 อาร์มแรกจึงถูกเลือกทำงาน
หาก num มีค่าเป็น Some(5) แทน การ์ด match ในอาร์มแรกก็จะได้ผลลัพธ์เป็น false เพราะเศษจากการหาร 5 ด้วย 2 คือ 1 ซึ่งไม่เท่ากับ 0 Rust ก็จะข้ามไปยังอาร์มที่สอง ซึ่งจะจับคู่สำเร็จเนื่องจากอาร์มที่สองไม่มีการ์ด match จึงยอมรับวาเรียนต์ Some ใดก็ได้
เนื่องจากเราไม่สามารถเขียนเงื่อนไข if x % 2 == 0 ลงในแพตเทิร์นตรง ๆ ได้ การ์ด match จึงเข้ามาช่วยให้เราแสดงตรรกะนี้ได้อย่างสะดวก ทว่าข้อแลกเปลี่ยนของความยืดหยุ่นที่เพิ่มขึ้นนี้คือ คอมไพเลอร์จะไม่สามารถตรวจสอบความครอบคลุมทุกกรณี (exhaustiveness) ของแพตเทิร์นได้อย่างสมบูรณ์เมื่อมีการใช้การ์ด match ร่วมด้วย
ในการพูดคุยถึงลิสติ้ง 19-11 เราเคยกล่าวไว้ว่าเราสามารถใช้การ์ด match เพื่อแก้ปัญหาการบดบังตัวแปร (shadowing) ในแพตเทิร์นได้ ย้อนกลับไปในตัวอย่างนั้น เราสร้างตัวแปรใหม่ขึ้นมาภายในแพตเทิร์นของนิพจน์ match แทนที่จะเป็นตัวแปรภายนอก ส่งผลให้เราไม่สามารถตรวจสอบเปรียบเทียบกับค่าของตัวแปรภายนอกได้ ลิสติ้ง 19-27 แสดงวิธีใช้การ์ด match เพื่อแก้ไขปัญหานี้
fn main() {
let x = Some(5);
let y = 10;
match x {
Some(50) => println!("Got 50"),
Some(n) if n == y => println!("Matched, n = {n}"),
_ => println!("Default case, x = {x:?}"),
}
println!("at the end: x = {x:?}, y = {y}");
}
โค้ดนี้จะพิมพ์ Default case, x = Some(5) แพตเทิร์นในอาร์มที่สองไม่ได้ประกาศตัวแปร y ขึ้นมาใหม่ที่จะไปบดบัง y ตัวนอก ซึ่งหมายความว่าเราสามารถนำ y ตัวนอกมาใช้ในการ์ด match ได้ โดยแทนที่เราจะกำหนดแพตเทิร์นเป็น Some(y) (ซึ่งจะบดบัง y ตัวนอก) เราเปลี่ยนมากำหนดเป็น Some(n) แทน ซึ่งจะสร้างตัวแปรใหม่ n ที่ไม่ได้ไปบดบังตัวแปรใด ๆ เลย เพราะไม่มีตัวแปรชื่อ n อยู่ภายนอก match
การ์ด match if n == y ไม่ใช่แพตเทิร์น จึงไม่มีการประกาศตัวแปรใหม่ ดังนั้น y ในที่นี้ คือ y ตัวนอกจริง ๆ ไม่ใช่ y ตัวใหม่ที่ไปบดบังมัน เราจึงสามารถตรวจสอบหาค่าที่ตรงกับ y ตัวนอกได้โดยการเปรียบเทียบ n กับ y
นอกจากนี้ คุณยังสามารถใช้ตัวดำเนินการ หรือ | ร่วมกับการ์ด match เพื่อกำหนดหลายแพตเทิร์นได้ โดยเงื่อนไขของการ์ด match จะมีผลกับทุก ๆ แพตเทิร์นที่ระบุ ลิสติ้ง 19-28 แสดงลำดับความสำคัญเมื่อรวมแพตเทิร์นที่ใช้ | เข้ากับการ์ด match สิ่งสำคัญของตัวอย่างนี้คือ การ์ด match if y จะมีผลครอบคลุมทั้ง 4, 5 และ 6 แม้ว่าเมื่อมองดูอาจเหมือนกับว่า if y มีผลเฉพาะกับ 6 เท่านั้นก็ตาม
fn main() {
let x = 4;
let y = false;
match x {
4 | 5 | 6 if y => println!("yes"),
_ => println!("no"),
}
}
เงื่อนไขของ match ระบุว่าอาร์มจะจับคู่สำเร็จก็ต่อเมื่อค่าของ x เท่ากับ 4, 5 หรือ 6 และ y มีค่าเป็น true เมื่อโค้ดนี้ทำงาน แพตเทิร์นของอาร์มแรกจับคู่สำเร็จเพราะ x มีค่าเป็น 4 แต่เนื่องจากการ์ด match if y เป็น false อาร์มแรกจึงไม่ถูกเลือก โค้ดจึงดำเนินต่อไปยังอาร์มที่สองซึ่งจับคู่สำเร็จ และโปรแกรมนี้จะพิมพ์ no ออกมา เหตุผลก็คือเงื่อนไข if จะมีผลกับแพตเทิร์นทั้งหมดคือ 4 | 5 | 6 ไม่ใช่แค่ค่าสุดท้ายคือ 6 กล่าวคือ ลำดับความสำคัญของการ์ด match เมื่อเทียบกับแพตเทิร์นจะมีพฤติกรรมดังนี้:
(4 | 5 | 6) if y => ...
ไม่ใช่แบบนี้:
4 | 5 | (6 if y) => ...
เมื่อรันโค้ดแล้ว พฤติกรรมของลำดับความสำคัญนี้จะเห็นได้อย่างชัดเจน: เพราะหากการ์ด match มีผลเฉพาะกับค่าสุดท้ายในรายการที่เชื่อมด้วยตัวดำเนินการ | แล้วล่ะก็ อาร์มแรกก็ย่อมจะจับคู่สำเร็จ และโปรแกรมก็จะพิมพ์ yes ออกมาแทน
การใช้การผูกค่าด้วย @
ตัวดำเนินการ at @ ช่วยให้เราสร้างตัวแปรเพื่อเก็บค่าไปพร้อม ๆ กับการทดสอบค่านั้นกับแพตเทิร์น ในลิสติ้ง 19-29 เราต้องการทดสอบว่าฟิลด์ id ของ Message::Hello อยู่ในช่วง 3..=7 หรือไม่ พร้อมทั้งต้องการผูกค่านั้นเข้ากับตัวแปร id เพื่อให้เราสามารถนำค่านั้นไปใช้งานในโค้ดของอาร์มดังกล่าวได้ด้วย
fn main() {
enum Message {
Hello { id: i32 },
}
let msg = Message::Hello { id: 5 };
match msg {
Message::Hello { id: id @ 3..=7 } => {
println!("Found an id in range: {id}")
}
Message::Hello { id: 10..=12 } => {
println!("Found an id in another range")
}
Message::Hello { id } => println!("Found some other id: {id}"),
}
}
ตัวอย่างนี้จะพิมพ์ Found an id in range: 5 ออกมา โดยการระบุ id @ ไว้ข้างหน้าช่วง 3..=7 เราจะดักจับค่าใดก็ตามที่จับคู่ตรงกับช่วงนั้นมาเก็บไว้ในตัวแปรชื่อ id ไปพร้อมกับทดสอบว่าค่านั้นตรงตามเงื่อนไขของช่วงหรือไม่
ในอาร์มที่สอง ซึ่งเราระบุเพียงช่วงในแพตเทิร์น โค้ดในอาร์มนั้นจะไม่มีตัวแปรที่เก็บค่าจริงของฟิลด์ id เลย ค่าของฟิลด์ id อาจเป็น 10, 11 หรือ 12 แต่โค้ดของอาร์มนั้นไม่รู้แน่ชัดว่าเป็นค่าใดกันแน่ จึงไม่สามารถนำค่าจากฟิลด์ id มาใช้งานได้เพราะเราไม่ได้บันทึกค่า id ไว้ในตัวแปรใด
ในอาร์มสุดท้าย ซึ่งเราระบุตัวแปรไว้โดยไม่มีช่วง เราจะมีค่าพร้อมใช้งานในโค้ดของอาร์มผ่านตัวแปรชื่อ id เนื่องจากเราใช้ไวยากรณ์แบบย่อของฟิลด์ struct ทว่าเราไม่ได้ใส่การทดสอบเงื่อนไขใด ๆ กับค่าในฟิลด์ id ในอาร์มนี้เหมือนกับสองอาร์มแรก: ค่าใดก็ตามจึงสามารถจับคู่กับแพตเทิร์นนี้ได้ทั้งหมด
การใช้ @ ช่วยให้เราทดสอบค่าและบันทึกค่านั้นไว้ในตัวแปรได้จบครบภายในแพตเทิร์นเดียว
สรุป
แพตเทิร์นของ Rust มีประโยชน์อย่างยิ่งในการจำแนกความแตกต่างระหว่างข้อมูลชนิดต่าง ๆ เมื่อนำไปใช้ในนิพจน์ match แล้ว Rust จะช่วยรับประกันว่าแพตเทิร์นของคุณครอบคลุมทุกค่าที่เป็นไปได้เสมอ มิฉะนั้นโปรแกรมก็จะไม่ผ่านการคอมไพล์ นอกจากนี้ แพตเทิร์นในสเตตเมนต์ let และพารามิเตอร์ของฟังก์ชันยังช่วยเพิ่มประโยชน์ให้แก่โครงสร้างคำสั่งเหล่านั้น โดยเปิดทางให้เราแยกโครงสร้างข้อมูลออกเป็นชิ้นส่วนย่อย ๆ และกำหนดค่านั้นให้แก่ตัวแปรได้อย่างสะดวก เราจึงสามารถสร้างแพตเทิร์นทั้งแบบเรียบง่ายหรือแบบซับซ้อนให้ตรงกับความต้องการของงานได้อย่างยืดหยุ่น
ในบทถัดไป ซึ่งเป็นบทรองสุดท้ายของหนังสือเล่มนี้ เราจะไปสำรวจแง่มุมและคุณลักษณะขั้นสูงต่าง ๆ ของฟีเจอร์ในภาษา Rust กัน