0Pricing
Learn Rust Coding · บทเรียน

เจาะลึก match

รูปแบบและตัวป้องกัน

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

นิพจน์ match

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

fn main() {
    let n = 3;
    let label = match n {
        1 => "one",
        2 => "two",
        3 => "three",
        _ => "many",
    };
    println!("{label}");
}

ความครอบคลุมครบถ้วน

match ต้องครอบคลุมค่าที่เป็นไปได้ทุกค่า อักขระแทนค่า _ จะจับทุกสิ่งที่ไม่ตรงกับแขนงก่อนหน้า จึงทำให้ครอบคลุมครบถ้วน

fn main() {
    let x = 42;
    match x {
        0 => println!("zero"),
        _ => println!("nonzero"),
    }
}

การจับคู่หลายค่า

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

fn main() {
    let c = 'e';
    match c {
        'a' | 'e' | 'i' | 'o' | 'u' => println!("vowel"),
        _ => println!("consonant"),
    }
}

รูปแบบช่วงค่า

จับคู่ช่วงค่าด้วย ..= (รวมค่าปลายช่วง) เหมาะสำหรับจัดกลุ่มตัวเลขหรืออักขระ

fn main() {
    let score = 85;
    let grade = match score {
        90..=100 => 'A',
        80..=89 => 'B',
        70..=79 => 'C',
        _ => 'F',
    };
    println!("Grade: {grade}");
}

เงื่อนไขกำกับการจับคู่

เงื่อนไขกำกับ คือเงื่อนไข if เพิ่มเติมบนแขนง แขนงนั้นจะจับคู่ได้ก็ต่อเมื่อรูปแบบตรงกัน และ เงื่อนไขกำกับเป็นจริง

fn main() {
    let pair = (2, -2);
    match pair {
        (x, y) if x + y == 0 => println!("sum is zero"),
        (x, _) if x % 2 == 0 => println!("first is even"),
        _ => println!("no rule"),
    }
}

การผูกค่าในรูปแบบ

รูปแบบสามารถผูกส่วนที่จับคู่ได้ไว้กับตัวแปร เพื่อใช้ในเนื้อหาของแขนง

fn main() {
    let msg = Some(7);
    match msg {
        Some(n) => println!("got {n}"),
        None => println!("nothing"),
    }
}

การจับคู่ enum

match เหมาะอย่างยิ่งกับ enum โดยเฉพาะเมื่อแต่ละรูปแบบย่อยมีข้อมูลอยู่ภายใน

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

fn area(s: Shape) -> f64 {
    match s {
        Shape::Circle(r) => 3.14159 * r * r,
        Shape::Rectangle(w, h) => w * h,
    }
}

fn main() {
    println!("{}", area(Shape::Rectangle(3.0, 4.0)));
}

การละเว้นด้วย _ และ ..

ใช้ _ เพื่อละเว้นค่าเดียว และใช้ .. เพื่อละเว้นส่วนที่เหลือของทูเพิลหรือโครงสร้าง

fn main() {
    let triple = (1, 2, 3);
    match triple {
        (first, ..) => println!("first is {first}"),
    }
}

การคืนค่าจาก match

เนื่องจาก match เป็นนิพจน์ คุณจึงกำหนดผลลัพธ์ให้ตัวแปรหรือคืนค่าโดยตรงได้ ทุกแขนงต้องให้ผลลัพธ์เป็นชนิดเดียวกัน

fn describe(n: i32) -> &'static str {
    match n.cmp(&0) {
        std::cmp::Ordering::Less => "negative",
        std::cmp::Ordering::Equal => "zero",
        std::cmp::Ordering::Greater => "positive",
    }
}

fn main() {
    println!("{}", describe(-5));
}

ลำดับของแขนงมีความสำคัญ

ระบบตรวจสอบแขนงจากบนลงล่าง แขนงแรกที่ตรงกันจะเป็นผลลัพธ์ ให้ใส่รูปแบบที่เฉพาะเจาะจงไว้ก่อนรูปแบบทั่วไป และวางอักขระแทนค่าไว้ท้ายสุด

การผูกช่วงค่าด้วย @

รวมช่วงค่ากับตัวดำเนินการ @ เพื่อทดสอบค่าและเก็บเนื้อหาที่แน่นอนของค่านั้นไว้ในแขนงเดียวกัน

fn main() {
    let n = 42;
    match n {
        small @ 0..=9 => println!("single digit: {small}"),
        big @ 10..=99 => println!("two digits: {big}"),
        _ => println!("large"),
    }
}

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

เงื่อนไขกำกับการจับคู่ เช่น (x, y) if x > y มีจุดประสงค์อะไร

สรุปทบทวน

คุณได้ศึกษา match อย่างละเอียด:

  • เป็นนิพจน์ที่ต้องครอบคลุมครบถ้วนและคืนค่าได้
  • | ใช้จับคู่หลายรูปแบบ ส่วน ..= ใช้จับคู่ช่วงค่า
  • เงื่อนไขกำกับใช้เพิ่มเงื่อนไข if
  • รูปแบบผูกข้อมูลได้ ส่วน _ และ .. ใช้ละเว้นบางส่วน
  • ลำดับของแขนงมีความสำคัญ แขนงแรกที่ตรงกันจะเป็นผลลัพธ์

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

บทเรียน “เจาะลึก match” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “เจาะลึก match”

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

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

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

บทเรียน “เจาะลึก match” ใช้เวลานานแค่ไหน

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

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

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

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

  1. เจาะลึก match
  2. if let และ while let
  3. การผูกค่าด้วย @
  4. การแยกโครงสร้าง
← กลับไปที่ Learn Rust Coding