Learn Rust Coding · บทเรียน

การจับคู่รูปแบบอันทรงพลัง

เชี่ยวชาญนิพจน์ `match` และโครงสร้างการจับคู่รูปแบบอื่น ๆ เพื่อจัดการรูปแบบต่าง ๆ ของข้อมูลได้อย่างกระชับและครบถ้วน

บทเรียน 3 จาก 311 ขั้นตอน

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

ปลดปล่อยพลังของการจับคู่รูปแบบ

ยินดีต้อนรับสู่โลกของการจับคู่รูปแบบใน Rust ฟีเจอร์อันทรงพลังนี้ช่วยให้คุณควบคุมลำดับการทำงานของโปรแกรมโดยอิงตามโครงสร้างของข้อมูล

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

แนวคิดนี้คล้ายกับคำสั่ง if/else หรือ switch ที่มีความสามารถมากยิ่งขึ้น
ช่วยให้ครอบคลุมทุกกรณี: คุณต้องจัดการรูปแบบที่เป็นไปได้ทั้งหมด
ทำให้โค้ดอ่านง่ายและทำงานได้มั่นคงยิ่งขึ้น

พื้นฐานของนิพจน์ `match`

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

แต่ละ “แขนง” ของนิพจน์ match ประกอบด้วยรูปแบบและโค้ดที่จะทำงานเมื่อรูปแบบนั้นตรงกัน

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

fn main() {
  let my_direction = Direction::North;

  match my_direction {
    Direction::North => println!("Going up!"),
    Direction::East => println!("Going right!"),
    Direction::South => println!("Going down!"),
    Direction::West => println!("Going left!"),
  }
}

การจับคู่ค่าคงที่และช่วงค่า

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

โปรดจำไว้ว่ารูปแบบจะถูกตรวจสอบตามลำดับ และจะใช้รูปแบบแรกที่ตรงกัน

fn main() {
  let x = 7;

  match x {
    1 => println!("It's one!"),
    2 | 3 => println!("It's two or three!"),
    4..=8 => println!("It's between four and eight!"),
    _ => println!("It's something else!"), // Catch-all
  }

  let character = 'b';
  match character {
    'a'..='e' => println!("Early letter"),
    _ => println!("Other letter"),
  }
}

การแยกโครงสร้างของ Struct

การจับคู่รูปแบบจะแสดงประโยชน์ได้อย่างเต็มที่เมื่อใช้แยกโครงสร้างชนิดข้อมูลที่ซับซ้อน เช่น โครงสร้าง คุณสามารถดึงฟิลด์แต่ละรายการไปใส่ในตัวแปรได้โดยตรงภายในแขนงของ match

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

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!("Not on an axis: ({}, {})", x, y),
  }
}

การแยกโครงสร้างของ Enum ที่มีข้อมูล

Enum ใน Rust สามารถเก็บข้อมูลที่เกี่ยวข้องไว้ได้ การจับคู่รูปแบบเป็นวิธีหลักในการดึงข้อมูลนี้ออกจากรูปแบบของ enum

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

enum Message {
  Quit,
  Move { x: i32, y: i32 },
  Write(String),
  ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
  match msg {
    Message::Quit => println!("Quit message."),
    Message::Move { x, y } => {
      println!("Move to x: {}, y: {}", x, y);
    }
    Message::Write(text) => println!("Text message: {}", text),
    Message::ChangeColor(r, g, b) => {
      println!("Color: R:{}, G:{}, B:{}", r, g, b);
    }
  }
}

fn main() {
  process_message(Message::Move { x: 10, y: 20 });
  process_message(Message::Write(String::from("Hello!")));
}

รูปแบบไวลด์การ์ด `_`

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

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

fn main() {
  let some_value = Some(5);
  let absent_value: Option<i32> = None;

  match some_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("Something else!"), // Matches None too
  }

  match absent_value {
    Some(x) => println!("Got a value: {}", x),
    _ => println!("No value here!"),
  }
}

`if let` สำหรับรูปแบบเดียว

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

กล่าวโดยสรุปคือ “ถ้ารูปแบบนี้ตรงกัน ให้ทำสิ่งนี้ มิฉะนั้นไม่ต้องทำอะไร (หรือเรียกใช้บล็อก else ที่เป็นตัวเลือก)”

fn main() {
  let config_max = Some(3u8);
  let none_value: Option<u8> = None;

  if let Some(max) = config_max {
    println!("Max configured to be: {}", max);
  }

  if let Some(val) = none_value {
    println!("This won't print: {}", val);
  } else {
    println!("No value found!");
  }
}

`while let` สำหรับลูปแบบมีเงื่อนไข

เช่นเดียวกับ if let ตรงที่ while let ช่วยให้คุณวนลูปต่อไปตราบใดที่รูปแบบยังคงตรงกัน

วิธีนี้มีประโยชน์อย่างมากเมื่อต้องประมวลผลรายการจากคอลเลกชัน เช่น Vec โดยต้องการทำต่อไปจนกว่าจะไม่มีองค์ประกอบที่ตรงกันเหลืออยู่ เช่น จนกว่า pop() จะส่งคืนค่า None

fn main() {
  let mut stack = vec![1, 2, 3];

  while let Some(top) = stack.pop() {
    println!("Popped: {}", top);
  }

  println!("Stack is empty now.");
}

ตัวคุมการจับคู่: การเพิ่มเงื่อนไข

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

วิธีนี้ช่วยให้ควบคุมรายละเอียดภายในรูปแบบได้มากขึ้น โดยไม่จำเป็นต้องสร้างรูปแบบ enum เพิ่ม

fn main() {
  let num = Some(4);

  match num {
    Some(x) if x % 2 == 0 => println!("Even number: {}", x),
    Some(x) if x < 5 => println!("Small odd number: {}", x),
    Some(x) => println!("Any other number: {}", x),
    None => println!("No number"),
  }
}

โจทย์ท้าทายการจับคู่รูปแบบ

พิจารณาข้อมูลโค้ด Rust ต่อไปนี้ ข้อความใดต่อไปนี้เป็นจริงเกี่ยวกับนิพจน์ match และผลลัพธ์ของมัน

enum Status {
  Loading,
  Success(u32),
  Error(String),
}

fn process_status(s: Status) {
  match s {
    Status::Success(code) if code > 200 => println!("Success with high code: {}", code),
    Status::Success(code) => println!("Success with code: {}", code),
    Status::Error(msg) => println!("Failed: {}", msg),
    _ => println!("Status unknown or loading..."),
  }
}

fn main() {
  process_status(Status::Success(201));
  process_status(Status::Error(String::from("Network issue")));
  process_status(Status::Loading);
  process_status(Status::Success(200));
}

ตอบคำถามในบทเรียนแบบโต้ตอบ

ทบทวน: เชี่ยวชาญการใช้รูปแบบ

คุณได้สำรวจพลังอันน่าทึ่งของการจับคู่รูปแบบใน Rust แล้ว นี่เป็นแนวคิดพื้นฐานสำหรับการเขียนโค้ดที่ชัดเจน กระชับ และปลอดภัย

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

ฝึกใช้รูปแบบเหล่านี้ต่อไป เพราะเป็นสิ่งสำคัญสำหรับการเขียน Rust ตามแนวทางที่เหมาะสม

เริ่มต้นได้ฟรี

เรียนรู้ Rust ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 39
บทเรียน: 144

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

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

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

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

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

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

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

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

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

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

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

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

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