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

ทุกจุดที่ใช้แพตเทิร์นได้

แพตเทิร์นปรากฏอยู่ในหลายจุดทั่วทั้งภาษา 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) เราจะไปเจาะลึกสองแนวคิดนี้กันในหัวข้อถัดไป