Learn Rust Coding · บทเรียน

จับคู่กับรูปแบบของ enum

ใช้ match เพื่อจัดการแต่ละกรณี

จับคู่กับรูปแบบของ enum เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

มาทำความรู้จักนิพจน์ match

นิพจน์ match เปรียบเทียบค่ากับรูปแบบหลายรูปแบบ แล้วเรียกใช้โค้ดของรูปแบบแรกที่ตรงกัน

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

enum Light {
    Red,
    Green,
}

fn action(l: Light) {
    match l {
        Light::Red => println!("Stop"),
        Light::Green => println!("Go"),
    }
}

โครงสร้างของแขนง match

แต่ละ แขนง มีรูปแบบเป็น pattern => expression และแขนงจะแยกจากกันด้วยจุลภาค

รูปแบบคือสิ่งที่ต้องนำมาเปรียบเทียบ ส่วนนิพจน์หลัง => จะทำงานเมื่อจับคู่ได้ ในที่นี้รูปแบบคือรูปแบบย่อยของ enum หนึ่งรูปแบบ

match light {
    Light::Red => println!("Stop"),
    Light::Green => println!("Go"),
}

โปรแกรมจับคู่แบบเต็มรูปแบบ

นี่คือโปรแกรมฉบับสมบูรณ์ที่จับคู่กับสัญญาณไฟจราจรและแสดงคำแนะนำ

ลองเรียกใช้โปรแกรม แล้วเปลี่ยนรูปแบบย่อยใน main เพื่อดูว่าแขนงใดทำงาน

enum TrafficLight {
    Red,
    Yellow,
    Green,
}

fn main() {
    let light = TrafficLight::Yellow;
    match light {
        TrafficLight::Red => println!("Stop"),
        TrafficLight::Yellow => println!("Slow down"),
        TrafficLight::Green => println!("Go"),
    }
}

match ต้องครอบคลุมทุกกรณี

Rust กำหนดให้ match ครอบคลุมรูปแบบย่อยที่เป็นไปได้ ทุกแบบ หากคุณลืมรูปแบบใด โปรแกรมจะคอมไพล์ไม่สำเร็จ

นี่เป็นคุณลักษณะด้านความปลอดภัยที่ทรงพลัง เมื่อเพิ่มรูปแบบย่อยใหม่ในภายหลัง คอมไพเลอร์จะเตือนคุณในทุกจุดที่ต้องจัดการรูปแบบนั้น

// This would FAIL to compile because
// the Green case is missing:
// match light {
//     Light::Red => println!("Stop"),
// }

การจับคู่แบบครอบคลุมด้วย _

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

วางรูปแบบนี้ไว้ท้ายสุด เพราะแขนงจะถูกลองตามลำดับ

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn main() {
    let c = Coin::Dime;
    match c {
        Coin::Penny => println!("1 cent"),
        _ => println!("Some other coin"),
    }
}

match ส่งคืนค่า

match เป็น นิพจน์ จึงสร้างค่าที่คุณเก็บไว้ในตัวแปรได้

ทุกแขนงต้องส่งคืนชนิดข้อมูลเดียวกัน โปรดสังเกตว่าไม่มีเครื่องหมายอัฒภาคหลังนิพจน์ของแต่ละแขนงในที่นี้

enum Coin {
    Penny,
    Quarter,
}

fn main() {
    let coin = Coin::Quarter;
    let cents = match coin {
        Coin::Penny => 1,
        Coin::Quarter => 25,
    };
    println!("{} cents", cents);
}

เนื้อหาแขนงหลายบรรทัด

แขนงหนึ่งสามารถเรียกใช้คำสั่งหลายรายการได้ โดยครอบคำสั่งเหล่านั้นไว้ในวงเล็บปีกกา { ... }

นิพจน์สุดท้ายภายในวงเล็บปีกกาคือค่าที่แขนงนั้นส่งคืน

match light {
    Light::Red => {
        println!("Caution!");
        println!("Stop the car");
    }
    Light::Green => println!("Go"),
}

การรวมรูปแบบด้วย |

ใช้เครื่องหมายไปป์ | เพื่อจับคู่รูปแบบย่อยหลายแบบในแขนงเดียว เครื่องหมายนี้อ่านได้ว่า “หรือ”

วิธีนี้ช่วยหลีกเลี่ยงการเขียนเนื้อหาเดิมซ้ำสำหรับรูปแบบย่อยที่ควรมีพฤติกรรมเหมือนกัน

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn main() {
    let c = Coin::Nickel;
    match c {
        Coin::Penny | Coin::Nickel => println!("Small coin"),
        _ => println!("Bigger coin"),
    }
}

match เทียบกับ if/else

คุณอาจเรียง if / else if เพื่อตรวจสอบรูปแบบย่อยได้ แต่ match อ่านเข้าใจง่ายและปลอดภัยกว่า

เมื่อใช้ match คอมไพเลอร์จะตรวจสอบว่าคุณจัดการทุกกรณีแล้วหรือไม่ ส่วนการเรียงคำสั่ง if ไม่มีการรับประกันเช่นนั้น

การจับคู่และการแสดงผลพร้อมกัน

รูปแบบที่ใช้บ่อยคือการแปลงรูปแบบย่อยเป็นข้อความที่อ่านเป็นมิตร แล้วแสดงผลข้อความนั้น

ลองเรียกใช้โปรแกรมนี้และเปลี่ยนทิศทางที่เลือก เพื่อดูข้อความจากการจับคู่

enum Direction {
    North,
    South,
    East,
    West,
}

fn main() {
    let d = Direction::West;
    let name = match d {
        Direction::North => "North",
        Direction::South => "South",
        Direction::East => "East",
        Direction::West => "West",
    };
    println!("Heading {}", name);
}

ลำดับมีความสำคัญ

แขนงจะถูกตรวจสอบจากบนลงล่าง และการจับคู่ครั้งแรกจะเป็นผล ส่วนแขนงที่เหลือจะถูกข้าม

ด้วยเหตุนี้ รูปแบบที่ครอบคลุมทุกกรณีอย่าง _ จึงต้องอยู่ท้ายสุด หากวางไว้ก่อน มันจะจับคู่กับทุกค่าก่อนที่แขนงเฉพาะจะมีโอกาสทำงาน

ตรวจสอบอย่างรวดเร็ว

ตรวจสอบความเข้าใจของคุณเกี่ยวกับ match

สรุปทบทวน

คุณได้เรียนรู้ว่า match เปรียบเทียบค่ากับรูปแบบต่าง ๆ และเรียกใช้แขนงแรกที่ตรงกัน

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

คำถามที่พบบ่อย

บทเรียน “จับคู่กับรูปแบบของ enum” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “จับคู่กับรูปแบบของ enum” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “จับคู่กับรูปแบบของ enum”

ใช้ match เพื่อจัดการแต่ละกรณี คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “จับคู่กับรูปแบบของ enum” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Learn Rust Coding