Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

ความสามารถในการค้าน: แพตเทิร์นอาจจับคู่ไม่สำเร็จหรือไม่

แพตเทิร์น (pattern) แบ่งออกเป็นสองรูปแบบ ได้แก่: แพตเทิร์นที่อาจจับคู่ไม่สำเร็จ (refutable pattern) และแพตเทิร์นที่จับคู่สำเร็จเสมอ (irrefutable pattern) โดยแพตเทิร์นที่จะจับคู่สำเร็จกับทุกค่าที่เป็นไปได้เสมอ จัดเป็น แพตเทิร์นที่จับคู่สำเร็จเสมอ (irrefutable) ตัวอย่างเช่น x ในคำสั่ง let x = 5; เพราะ x สามารถจับคู่ได้กับทุกค่า จึงไม่มีทางที่จะจับคู่ไม่สำเร็จ ส่วนแพตเทิร์นที่มีโอกาสจับคู่ไม่สำเร็จกับบางค่า จัดเป็น แพตเทิร์นที่อาจจับคู่ไม่สำเร็จ (refutable) ตัวอย่างเช่น Some(x) ในนิพจน์ if let Some(x) = a_value เพราะหากค่าในตัวแปร a_value เป็น None แทนที่จะเป็น Some แพตเทิร์น Some(x) ย่อมจับคู่ไม่สำเร็จ

พารามิเตอร์ของฟังก์ชัน, สเตตเมนต์ let และลูป for จะรับได้เฉพาะแพตเทิร์นที่จับคู่สำเร็จเสมอเท่านั้น เพราะโปรแกรมไม่สามารถดำเนินการอะไรต่อได้อย่างสมเหตุสมผลหากค่าที่ได้ไม่ตรงกับแพตเทิร์น ส่วนนิพจน์ if let, while let และสเตตเมนต์ let...else นั้นยอมรับได้ทั้งแพตเทิร์นที่อาจจับคู่ไม่สำเร็จและแพตเทิร์นที่จับคู่สำเร็จเสมอ ทว่าคอมไพเลอร์จะแจ้งเตือนเมื่อใช้แพตเทิร์นที่จับคู่สำเร็จเสมอ เพราะโดยนิยามแล้ว โครงสร้างเหล่านี้มีจุดประสงค์เพื่อรับมือกับกรณีที่อาจไม่ตรงเงื่อนไข ซึ่งหน้าที่หลักของคำสั่งเงื่อนไขคือการเลือกทำงานแตกต่างกันไปตามผลลัพธ์ว่าสำเร็จหรือไม่

โดยทั่วไปแล้ว คุณแทบไม่ต้องกังวลถึงความแตกต่างระหว่างแพตเทิร์นทั้งสองแบบนี้เลย อย่างไรก็ตาม คุณจำเป็นต้องเข้าใจแนวคิดเรื่องความสามารถในการค้าน (refutability) เอาไว้ เพื่อให้สามารถแก้ไขโค้ดได้ทันทีเมื่อพบคำนี้ในข้อความแจ้งข้อผิดพลาด (error message) ซึ่งในกรณีดังกล่าว คุณจะต้องปรับเปลี่ยนตัวแพตเทิร์น หรือไม่ก็เปลี่ยนโครงสร้างคำสั่งที่นำแพตเทิร์นนั้นไปใช้งาน ทั้งนี้ขึ้นอยู่กับพฤติกรรมที่ต้องการให้โค้ดทำงาน

ลองมาดูตัวอย่างว่าเกิดอะไรขึ้นเมื่อเราพยายามนำแพตเทิร์นที่อาจจับคู่ไม่สำเร็จไปใช้ในจุดที่ Rust กำหนดให้ต้องเป็นแพตเทิร์นที่จับคู่สำเร็จเสมอ และในทางกลับกัน ลิสติ้ง 19-8 แสดงสเตตเมนต์ let ที่กำหนดแพตเทิร์นเป็น Some(x) ซึ่งเป็นแพตเทิร์นที่อาจจับคู่ไม่สำเร็จ แน่นอนว่าโค้ดนี้จะไม่ผ่านการคอมไพล์

fn main() {
    let some_option_value: Option<i32> = None;
    let Some(x) = some_option_value;
}

หาก some_option_value มีค่าเป็น None ก็จะไม่สามารถจับคู่กับแพตเทิร์น Some(x) ได้ ซึ่งหมายความว่าแพตเทิร์นนี้มีโอกาสจับคู่ไม่สำเร็จ (refutable) แต่สเตตเมนต์ let ยอมรับได้เฉพาะแพตเทิร์นที่จับคู่สำเร็จเสมอเท่านั้น เพราะตัวโค้ดไม่มีทางรู้เลยว่าจะต้องทำอย่างไรต่อไปหากได้ค่า None มา ตอนคอมไพล์ Rust จึงแจ้งข้อผิดพลาดว่าเราพยายามนำแพตเทิร์นที่อาจจับคู่ไม่สำเร็จไปใช้ในจุดที่ต้องเป็นแพตเทิร์นที่จับคู่สำเร็จเสมอ:

$ cargo run
   Compiling patterns v0.1.0 (file:///projects/patterns)
error[E0005]: refutable pattern in local binding
 --> src/main.rs:3:9
  |
3 |     let Some(x) = some_option_value;
  |         ^^^^^^^ pattern `None` not covered
  |
  = note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
  = note: for more information, visit https://doc.rust-lang.org/book/ch19-02-refutability.html
  = note: the matched value is of type `Option<i32>`
help: you might want to use `let...else` to handle the variant that isn't matched
  |
3 |     let Some(x) = some_option_value else { todo!() };
  |                                     ++++++++++++++++

For more information about this error, try `rustc --explain E0005`.
error: could not compile `patterns` (bin "patterns") due to 1 previous error

เนื่องจากแพตเทิร์น Some(x) ไม่ได้ครอบคลุม (และไม่มีทางครอบคลุมได้ทั้งหมด!) ทุกค่าที่เป็นไปได้ Rust จึงแจ้งข้อผิดพลาดจากการคอมไพล์อย่างถูกต้องสมเหตุสมผล

หากเราต้องการใช้แพตเทิร์นที่อาจจับคู่ไม่สำเร็จในตำแหน่งที่จำเป็นต้องเป็นแพตเทิร์นที่จับคู่สำเร็จเสมอ เราสามารถแก้ไขได้ด้วยการปรับเปลี่ยนโครงสร้างของโค้ด: โดยแทนที่จะใช้ let ปกติ เราสามารถเปลี่ยนมาใช้ let...else แทน ซึ่งหากแพตเทิร์นไม่ตรงกับค่าที่ได้ โค้ดในบล็อกวงเล็บปีกกาจะเข้ามาจัดการต่อให้ ลิสติ้ง 19-9 แสดงวิธีแก้ไขโค้ดจากลิสติ้ง 19-8

fn main() {
    let some_option_value: Option<i32> = None;
    let Some(x) = some_option_value else {
        return;
    };
}

เท่านี้โค้ดของเราก็มีทางออกเมื่อไม่ตรงเงื่อนไขแล้ว! โค้ดนี้จึงถูกต้องและทำงานได้สมบูรณ์ ทว่าในทางกลับกัน หากเรานำแพตเทิร์นที่จับคู่สำเร็จเสมอมาใช้กับ let...else คอมไพเลอร์ก็จะแจ้งคำเตือน ดังตัวอย่างในลิสติ้ง 19-10 ที่เรากำหนดแพตเทิร์นให้ let...else เป็น x ซึ่งเป็นแพตเทิร์นที่จับคู่สำเร็จเสมอ

fn main() {
    let x = 5 else {
        return;
    };
}

Rust จะแจ้งเตือนว่าการใช้ let...else ร่วมกับแพตเทิร์นที่จับคู่สำเร็จเสมอนั้นไม่สมเหตุสมผล เพราะบล็อก else จะไม่มีวันถูกเรียกทำงานเลย:

$ cargo run
   Compiling patterns v0.1.0 (file:///projects/patterns)
warning: unreachable `else` clause
 --> src/main.rs:2:15
  |
2 |     let x = 5 else {
  |     --------- ^^^^
  |     |
  |     assigning to binding pattern will always succeed
  |
  = note: this pattern always matches, so the else clause is unreachable
  = note: `#[warn(irrefutable_let_patterns)]` on by default

warning: `patterns` (bin "patterns") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.39s
     Running `target/debug/patterns`

ด้วยเหตุนี้ แต่ละอาร์มของ match จึงต้องใช้แพตเทิร์นที่อาจจับคู่ไม่สำเร็จ ยกเว้นอาร์มสุดท้ายที่ควรจับคู่ค่าที่เหลืออยู่ทั้งหมดด้วยแพตเทิร์นที่จับคู่สำเร็จเสมอ ทั้งนี้ Rust อนุญาตให้เราใช้แพตเทิร์นที่จับคู่สำเร็จเสมอใน match ที่มีเพียงอาร์มเดียวได้ แต่ไวยากรณ์รูปแบบนี้ไม่ได้มีประโยชน์อะไรเป็นพิเศษ และสามารถแทนที่ด้วยคำสั่ง let ธรรมดาที่กระชับกว่าได้

เมื่อเราได้เรียนรู้ตำแหน่งต่าง ๆ ที่สามารถนำแพตเทิร์นไปใช้งาน รวมถึงความแตกต่างระหว่างแพตเทิร์นที่อาจจับคู่ไม่สำเร็จและแพตเทิร์นที่จับคู่สำเร็จเสมอแล้ว ในหัวข้อถัดไป เราจะมาดูไวยากรณ์ทั้งหมดที่ใช้สร้างแพตเทิร์นกัน